From 7bc66f7bf1cf3008c1d61ca879aa69d35eb0b129 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 25 Sep 2023 17:42:58 +0900
Subject: [PATCH 001/337] Make Env jax-compatible

---
 noxfile.py              |  33 ++++++++++-
 pyproject.toml          |   6 +-
 requirements/cuda11.in  |   2 +
 requirements/cuda12.in  |   2 +
 requirements/jupyter.in |   9 +++
 requirements/smoke.in   |   2 +-
 src/emevo/body.py       | 100 --------------------------------
 src/emevo/env.py        |  87 +++++++++++++++-------------
 src/emevo/spaces.py     | 124 ++++++++++++++++++++--------------------
 src/emevo/status.py     |  27 +++++----
 src/emevo/types.py      |  17 ++++++
 11 files changed, 188 insertions(+), 221 deletions(-)
 create mode 100644 requirements/cuda11.in
 create mode 100644 requirements/cuda12.in
 create mode 100644 requirements/jupyter.in
 delete mode 100644 src/emevo/body.py
 create mode 100644 src/emevo/types.py

diff --git a/noxfile.py b/noxfile.py
index e1ae15f5..97592301 100644
--- a/noxfile.py
+++ b/noxfile.py
@@ -1,4 +1,8 @@
+from __future__ import annotations
+
 import pathlib
+import shutil
+import subprocess
 
 import nox
 
@@ -18,6 +22,10 @@ def _sync(session: nox.Session, requirements: str) -> None:
 def compile(session: nox.Session) -> None:
     session.install("pip-tools")
     requirements_dir = pathlib.Path("requirements")
+    has_cuda = shutil.which("ptxas") is not None
+    if has_cuda:
+        nvcc_out = subprocess.run(["nvcc", "--version"], capture_output=True)
+        is_cuda_12 = "cuda_12" in nvcc_out.stdout.decode("utf-8")
 
     def _run_pip_compile(in_file: str, out_name: str) -> None:
         # If -k {out_name} is given, skip compiling
@@ -25,8 +33,13 @@ def _run_pip_compile(in_file: str, out_name: str) -> None:
             return
 
         out_file = f"requirements/{out_name}.txt"
-        args = [
-            "pip-compile",
+        args = ["pip-compile"]
+        if has_cuda and out_name not in ["format", "lint"]:
+            if is_cuda_12:
+                args.append("requirements/cuda12.in")
+            else:
+                args.append("requirements/cuda11.in")
+        args += [
             in_file,
             "--output-file",
             out_file,
@@ -37,7 +50,8 @@ def _run_pip_compile(in_file: str, out_name: str) -> None:
         session.run(*args)
 
     for path in requirements_dir.glob("*.in"):
-        _run_pip_compile(path.as_posix(), path.stem)
+        if "cuda" not in path.stem:
+            _run_pip_compile(path.as_posix(), path.stem)
 
 
 @nox.session(reuse_venv=True)
@@ -61,6 +75,19 @@ def lint(session: nox.Session) -> None:
     session.run("isort", *SOURCES, "--check")
 
 
+@nox.session(reuse_venv=True)
+def lab(session: nox.Session) -> None:
+    _sync(session, "requirements/jupyter.txt")
+    session.run("python", "-m", "ipykernel", "install", "--user", "--name", "emevo-lab")
+    session.run("jupyter", "lab", *session.posargs)
+
+
+@nox.session(reuse_venv=True)
+def ipython(session: nox.Session) -> None:
+    _sync(session, "requirements/jupyter.txt")
+    session.run("python", "-m", "IPython")
+
+
 @nox.session(reuse_venv=True)
 def smoke(session: nox.Session) -> None:
     """Run a smoke test"""
diff --git a/pyproject.toml b/pyproject.toml
index 83a24363..0f391ae5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -17,10 +17,11 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Artificial Life",
     "Typing :: Typed",
 ]
-requires-python = ">= 3.8"
+requires-python = ">= 3.9"
 dependencies = [
+    "chex >= 0.1.82",
     "loguru >= 0.6",
-    "numpy >= 1.20",
+    "jax >= 0.4",
     "pymunk >= 6.0",
     "scipy >= 1.0",
     "typing_extensions >= 4.0"
@@ -32,7 +33,6 @@ moderngl = [
     "moderngl >= 5.6",
     "moderngl-window >= 2.4"
 ]
-pygame = ["pygame >= 2.0"]
 pyside6 = ["PySide6 >= 6.4.1"]
 video = ["imageio-ffmpeg >= 0.4"]
 
diff --git a/requirements/cuda11.in b/requirements/cuda11.in
new file mode 100644
index 00000000..d4160109
--- /dev/null
+++ b/requirements/cuda11.in
@@ -0,0 +1,2 @@
+--find-links https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+jax[cuda11_pip]
\ No newline at end of file
diff --git a/requirements/cuda12.in b/requirements/cuda12.in
new file mode 100644
index 00000000..a7bd282b
--- /dev/null
+++ b/requirements/cuda12.in
@@ -0,0 +1,2 @@
+--find-links https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+jax[cuda12_pip]
\ No newline at end of file
diff --git a/requirements/jupyter.in b/requirements/jupyter.in
new file mode 100644
index 00000000..9932bad5
--- /dev/null
+++ b/requirements/jupyter.in
@@ -0,0 +1,9 @@
+-r format.in
+-e .
+ipympl
+ipywidgets
+jupyterlab
+jupyterlab_code_formatter
+jupyterlab-lsp
+matplotlib
+seaborn
\ No newline at end of file
diff --git a/requirements/smoke.in b/requirements/smoke.in
index b7306af4..5ee29c24 100644
--- a/requirements/smoke.in
+++ b/requirements/smoke.in
@@ -1,3 +1,3 @@
--e .[moderngl,video,pygame,pyside6]
+-e .[moderngl,video,pyside6]
 tqdm
 typer
\ No newline at end of file
diff --git a/src/emevo/body.py b/src/emevo/body.py
deleted file mode 100644
index b6fc1a16..00000000
--- a/src/emevo/body.py
+++ /dev/null
@@ -1,100 +0,0 @@
-"""
-Abstract API for bodily existance of agents
-"""
-
-from __future__ import annotations
-
-import abc
-import dataclasses
-import functools
-from collections import defaultdict
-from typing import Any, Generic, NamedTuple, NoReturn, TypeVar
-
-from emevo.spaces import Space
-
-LOC = TypeVar("LOC")
-
-
-class Locatable(abc.ABC, Generic[LOC]):
-    @abc.abstractmethod
-    def location(self) -> LOC:
-        pass
-
-
-@dataclasses.dataclass(frozen=True)
-class Profile:
-    """Unique id for an agent."""
-
-    birthtime: int | float
-    generation: int
-    index: int
-
-    def __lt__(self, other: Profile) -> bool:
-        return self.index < other.index
-
-
-@functools.total_ordering
-class Body(Locatable[LOC], abc.ABC):
-    """
-    Reprsents the bodily existance of the agent.
-    Body should have an unique index, so it should work as an effecient key object.
-    """
-
-    _INDICES: dict[type, int] = defaultdict(int)
-
-    def __init__(
-        self,
-        act_space: Space,
-        obs_space: Space,
-        generation: int = 0,
-        birthtime: int | float = 0,
-        index: int | None = None,
-    ) -> None:
-        self.act_space = act_space
-        self.obs_space = obs_space
-        if index is None:
-            ty = type(self)
-            index = self._INDICES[ty]
-            self._INDICES[ty] += 1
-        self._profile = Profile(birthtime, generation, index)
-
-    def __deepcopy__(self) -> NoReturn:
-        raise RuntimeError("Body cannot be copied")
-
-    @property
-    def generation(self) -> int:
-        return self._profile.generation
-
-    @property
-    def index(self) -> int:
-        return self._profile.index
-
-    def info(self) -> Any:
-        """Returns some information useful for debugging"""
-        return None
-
-    def __repr__(self) -> str:
-        birthtime, gen, index = dataclasses.astuple(self._profile)
-        return f"Body {index} (gen: {gen} birth: {birthtime})"
-
-    def __eq__(self, other: Any) -> bool:
-        if isinstance(other, Body):
-            return self._profile == other._profile
-        else:
-            return False
-
-    def __lt__(self, other: Any) -> bool:
-        if isinstance(other, Body):
-            return self._profile < other._profile
-        else:
-            return True
-
-    def __hash__(self) -> int:
-        return hash(self._profile)
-
-
-class Encount(NamedTuple):
-    """Encounted two bodies"""
-
-    a: Body
-    b: Body
diff --git a/src/emevo/env.py b/src/emevo/env.py
index 364cf302..a750fe90 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -1,27 +1,47 @@
 """
-Abstract environment API.
+Abstract environment API inspired by jumanji
 """
 from __future__ import annotations
 
 import abc
-from typing import Generic, Iterable, Protocol, TypeVar
+from typing import Any, Generic, Protocol, TypeVar
 
-from numpy.typing import NDArray
+import chex
+import jax
+from jax.typing import ArrayLike
 
-from emevo.body import LOC, Body, Encount
+from emevo.types import Index, PyTree
 from emevo.visualizer import Visualizer
 
 
-class Observation(Protocol):
-    def __array__(self) -> NDArray:
-        ...
+@chex.dataclass
+class Profile:
+    """Agent profile."""
 
+    birthtime: jax.Array
+    generation: jax.Array
+    index: jax.Array
 
-ACT = TypeVar("ACT")
-OBS = TypeVar("OBS", bound=Observation)
 
+class StateProtocol(Protocol):
+    """Each state should have PRNG key"""
 
-class Env(abc.ABC, Generic[ACT, LOC, OBS]):
+    key: chex.PRNGKey
+
+
+STATE = TypeVar("STATE", bound="StateProtocol")
+
+OBS = TypeVar("OBS")
+
+
+@chex.dataclass
+class TimeStep:
+    encount: jax.Array | None
+    obs: PyTree
+    info: dict[str, Any]
+
+
+class Env(abc.ABC, Generic[STATE, OBS]):
     """Abstract API for emevo environments"""
 
     def __init__(self, *args, **kwargs) -> None:
@@ -29,12 +49,17 @@ def __init__(self, *args, **kwargs) -> None:
         pass
 
     @abc.abstractmethod
-    def bodies(self) -> list[Body[LOC]]:
-        """Returns all 'alive' bodies in the environment"""
+    def reset(self, key: chex.PRNGKey) -> STATE:
+        """Initialize environmental state."""
+        pass
+
+    @abc.abstractmethod
+    def profile(self) -> Profile:
+        """Returns profile of all 'alive' agents in the! environment"""
         pass
 
     @abc.abstractmethod
-    def step(self, actions: dict[Body[LOC], ACT]) -> list[Encount]:
+    def step(self, state: STATE, action: ArrayLike) -> tuple[STATE, TimeStep]:
         """
         Step the simulator by 1-step, taking the state and actions from each body.
         Returns the next state and all encounts.
@@ -42,27 +67,22 @@ def step(self, actions: dict[Body[LOC], ACT]) -> list[Encount]:
         pass
 
     @abc.abstractmethod
-    def observe(self, body: Body[LOC]) -> OBS:
-        """Construct the observation from the state"""
+    def activate(self, state: STATE, index: Index) -> STATE:
+        """Mark an agent or some agents active."""
         pass
 
     @abc.abstractmethod
-    def reset(self, seed: int | None = None) -> None:
-        """Do some initialization"""
-        pass
-
-    @abc.abstractmethod
-    def locate_body(self, location: LOC, generation: int) -> Body[LOC] | None:
-        """Taken a location, generate and place a newborn in the environment."""
-        pass
-
-    @abc.abstractmethod
-    def remove_body(self, body: Body[LOC]) -> bool:
-        """Remove a dead body from the environment."""
+    def deactivate(self, state: STATE, index: Index) -> STATE:
+        """
+        Deactivate an agent or some agents. The shape of observations should remain the
+        same so that `Env.step` is compiled onle once. So, to represent that an agent is
+        dead, it is recommended to mark that body is not active and reuse it after a new
+        agent is born.
+        """
         pass
 
     @abc.abstractmethod
-    def is_extinct(self) -> bool:
+    def is_extinct(self, state: STATE) -> bool:
         """Return if agents are extinct"""
         pass
 
@@ -70,14 +90,3 @@ def is_extinct(self) -> bool:
     def visualizer(self, *args, **kwargs) -> Visualizer:
         """Create a visualizer for the environment"""
         pass
-
-    def try_locate_body(
-        self,
-        locations: Iterable[LOC],
-        generation: int,
-    ) -> Body[LOC] | None:
-        for loc in locations:
-            body = self.locate_body(loc, generation)
-            if body is not None:
-                return body
-        return None
diff --git a/src/emevo/spaces.py b/src/emevo/spaces.py
index f22827f7..bc81fafb 100644
--- a/src/emevo/spaces.py
+++ b/src/emevo/spaces.py
@@ -1,22 +1,24 @@
-"""Similar to gym.spaces.Space, but doesn't have RNG"""
+"""Similar to gym.spaces.Space, but for jax"""
 from __future__ import annotations
 
 import abc
 from typing import Any, Generic, Iterable, NamedTuple, Sequence, TypeVar
 
-import numpy as np
-from numpy.random import Generator
-from numpy.typing import DTypeLike, NDArray
+import chex
+import jax
+import jax.numpy as jnp
+
+from emevo.types import DTypeLike
 
 INSTANCE = TypeVar("INSTANCE")
 
 
 class Space(abc.ABC, Generic[INSTANCE]):
-    dtype: np.dtype
+    dtype: jnp.dtype
     shape: tuple[int, ...]
 
     @abc.abstractmethod
-    def clip(self, x: NDArray) -> NDArray:
+    def clip(self, x: jax.Array) -> jax.Array:
         raise NotImplementedError()
 
     @abc.abstractmethod
@@ -28,34 +30,34 @@ def flatten(self) -> BoxSpace:
         raise NotImplementedError()
 
     @abc.abstractmethod
-    def sample(self, generator: Generator) -> INSTANCE:
+    def sample(self, key: chex.PRNGKey) -> INSTANCE:
         pass
 
 
-def _short_repr(arr: NDArray) -> str:
-    if arr.size != 0 and np.min(arr) == np.max(arr):
-        return str(np.min(arr))
+def _short_repr(arr: jax.Array) -> str:
+    if arr.size != 0 and jnp.min(arr) == jnp.max(arr):
+        return str(jnp.min(arr))
     return str(arr)
 
 
-class BoxSpace(Space[NDArray]):
+class BoxSpace(Space[jax.Array]):
     """gym.spaces.Box, but without RNG"""
 
     def __init__(
         self,
-        low: int | float | NDArray,
-        high: int | float | NDArray,
+        low: int | float | jax.Array,
+        high: int | float | jax.Array,
         shape: Sequence[int] | None = None,
-        dtype: DTypeLike = np.float32,
+        dtype: DTypeLike = jnp.float32,
     ) -> None:
-        self.dtype = np.dtype(dtype)
+        self.dtype = jnp.dtype(dtype)
 
         # determine shape if it isn't provided directly
         if shape is not None:
             shape = tuple(shape)
-        elif not np.isscalar(low):
+        elif not jnp.isscalar(low):
             shape = low.shape  # type: ignore
-        elif not np.isscalar(high):
+        elif not jnp.isscalar(high):
             shape = high.shape  # type: ignore
         else:
             raise ValueError(
@@ -64,18 +66,18 @@ def __init__(
         assert isinstance(shape, tuple)
         self.shape = shape
 
-        # Capture the boundedness information before replacing np.inf with get_inf
-        _low = np.full(shape, low, dtype=float) if np.isscalar(low) else low
-        self.bounded_below = -np.inf < _low  # type: ignore
-        _high = np.full(shape, high, dtype=float) if np.isscalar(high) else high
-        self.bounded_above = np.inf > _high  # type: ignore
+        # Capture the boundedness information before replacing jnp.inf with get_inf
+        _low = jnp.full(shape, low, dtype=float) if jnp.isscalar(low) else low
+        self.bounded_below = -jnp.inf < _low  # type: ignore
+        _high = jnp.full(shape, high, dtype=float) if jnp.isscalar(high) else high
+        self.bounded_above = jnp.inf > _high  # type: ignore
 
         low = _broadcast(low, dtype, shape, inf_sign="-")  # type: ignore
         high = _broadcast(high, dtype, shape, inf_sign="+")  # type: ignore
 
-        assert isinstance(low, np.ndarray)
+        assert isinstance(low, jax.Array)
         assert low.shape == shape, "low.shape doesn't match provided shape"
-        assert isinstance(high, np.ndarray)
+        assert isinstance(high, jax.Array)
         assert high.shape == shape, "high.shape doesn't match provided shape"
 
         self.low = low.astype(self.dtype)
@@ -85,8 +87,8 @@ def __init__(
         self.high_repr = _short_repr(self.high)
 
     def is_bounded(self, manner: str = "both") -> bool:
-        below = bool(np.all(self.bounded_below))
-        above = bool(np.all(self.bounded_above))
+        below = bool(jnp.all(self.bounded_below))
+        above = bool(jnp.all(self.bounded_above))
         if manner == "both":
             return below and above
         elif manner == "below":
@@ -96,23 +98,23 @@ def is_bounded(self, manner: str = "both") -> bool:
         else:
             raise ValueError("manner is not in {'below', 'above', 'both'}")
 
-    def clip(self, x: NDArray) -> NDArray:
-        return np.clip(x, a_min=self.low, a_max=self.high)
+    def clip(self, x: jax.Array) -> jax.Array:
+        return jnp.clip(x, a_min=self.low, a_max=self.high)
 
-    def contains(self, x: NDArray) -> bool:
+    def contains(self, x: jax.Array) -> bool:
         return bool(
-            np.can_cast(x.dtype, self.dtype)
+            jnp.can_cast(x.dtype, self.dtype)
             and x.shape == self.shape
-            and np.all(x >= self.low)
-            and np.all(x <= self.high)
+            and jnp.all(x >= self.low)
+            and jnp.all(x <= self.high)
         )
 
     def flatten(self) -> BoxSpace:
         return BoxSpace(low=self.low.flatten(), high=self.high.flatten())
 
-    def sample(self, generator: Generator) -> NDArray:
+    def sample(self, generator: Generator) -> jax.Array:
         high = self.high if self.dtype.kind == "f" else self.high.astype("int64") + 1
-        sample = np.empty(self.shape)
+        sample = jnp.empty(self.shape)
 
         # Masking arrays which classify the coordinates according to interval
         # type
@@ -136,10 +138,10 @@ def sample(self, generator: Generator) -> NDArray:
             low=self.low[bounded], high=high[bounded], size=bounded[bounded].shape
         )
         if self.dtype.kind == "i":
-            sample = np.floor(sample)
+            sample = jnp.floor(sample)
         return sample.astype(self.dtype)
 
-    def normalize(self, normalized: NDArray) -> NDArray:
+    def normalize(self, normalized: jax.Array) -> jax.Array:
         range_ = self.high - self.low  # type: ignore
         return (normalized - self.low) / range_  # type: ignore
 
@@ -151,29 +153,29 @@ def __eq__(self, other) -> bool:
         return (
             isinstance(other, self.__class__)
             and (self.shape == other.shape)
-            and np.allclose(self.low, other.low)
-            and np.allclose(self.high, other.high)
+            and jnp.allclose(self.low, other.low)
+            and jnp.allclose(self.high, other.high)
         )
 
 
 def get_inf(dtype, sign: str) -> int | float:
     """Returns an infinite that doesn't break things.
     Args:
-        dtype: An `np.dtype`
+        dtype: An `jnp.dtype`
         sign (str): must be either `"+"` or `"-"`
     """
-    if np.dtype(dtype).kind == "f":
+    if jnp.dtype(dtype).kind == "f":
         if sign == "+":
-            return np.inf
+            return jnp.inf
         elif sign == "-":
-            return -np.inf
+            return -jnp.inf
         else:
             raise TypeError(f"Unknown sign {sign}, use either '+' or '-'")
-    elif np.dtype(dtype).kind == "i":
+    elif jnp.dtype(dtype).kind == "i":
         if sign == "+":
-            return np.iinfo(dtype).max - 2
+            return jnp.iinfo(dtype).max - 2
         elif sign == "-":
-            return np.iinfo(dtype).min + 2
+            return jnp.iinfo(dtype).min + 2
         else:
             raise TypeError(f"Unknown sign {sign}, use either '+' or '-'")
     else:
@@ -181,21 +183,21 @@ def get_inf(dtype, sign: str) -> int | float:
 
 
 def _broadcast(
-    value: int | float | NDArray,
+    value: int | float | jax.Array,
     dtype,
     shape: tuple[int, ...],
     inf_sign: str,
-) -> NDArray:
+) -> jax.Array:
     """Handle infinite bounds and broadcast at the same time if needed."""
-    if np.isscalar(value):
-        value = get_inf(dtype, inf_sign) if np.isinf(value) else value  # type: ignore
-        value = np.full(shape, value, dtype=dtype)
+    if jnp.isscalar(value):
+        value = get_inf(dtype, inf_sign) if jnp.isinf(value) else value  # type: ignore
+        value = jnp.full(shape, value, dtype=dtype)
     else:
-        assert isinstance(value, np.ndarray)
-        if np.any(np.isinf(value)):
-            # create new array with dtype, but maintain old one to preserve np.inf
+        assert isinstance(value, jnp.ndarray)
+        if jnp.any(jnp.isinf(value)):
+            # create new array with dtype, but maintain old one to preserve jnp.inf
             temp = value.astype(dtype)
-            temp[np.isinf(value)] = get_inf(dtype, inf_sign)
+            temp[jnp.isinf(value)] = get_inf(dtype, inf_sign)
             value = temp
     return value
 
@@ -205,8 +207,8 @@ class DiscreteSpace(Space[int]):
 
     def __init__(self, n: int, start: int = 0) -> None:
         assert n > 0, "n (counts) have to be positive"
-        assert isinstance(start, (int, np.integer))
-        self.dtype = np.dtype(int)
+        assert isinstance(start, (int, jnp.integer))
+        self.dtype = jnp.dtype(int)
         self.shape = ()
         self.n = int(n)
         self.start = int(start)
@@ -218,8 +220,8 @@ def contains(self, x: int) -> bool:
         """Return boolean specifying if x is a valid member of this space."""
         if isinstance(x, int):
             as_int = x
-        elif isinstance(x, (np.generic, np.ndarray)) and (
-            x.dtype.char in np.typecodes["AllInteger"] and x.shape == ()
+        elif isinstance(x, (jnp.generic, jnp.ndarray)) and (
+            x.dtype.char in jnp.typecodes["AllInteger"] and x.shape == ()
         ):
             as_int = int(x)  # type: ignore
         else:
@@ -227,7 +229,7 @@ def contains(self, x: int) -> bool:
         return self.start <= as_int < self.start + self.n
 
     def flatten(self) -> BoxSpace:
-        return BoxSpace(low=np.zeros(self.n), high=np.ones(self.n))
+        return BoxSpace(low=jnp.zeros(self.n), high=jnp.ones(self.n))
 
     def sample(self, generator: Generator) -> int:
         return int(self.start + generator.integers(self.n))
@@ -290,8 +292,8 @@ def contains(self, x: tuple) -> bool:
 
     def flatten(self) -> BoxSpace:
         spaces = [space.flatten() for space in self.spaces]
-        low = np.concatenate([space.low for space in spaces])
-        high = np.concatenate([space.high for space in spaces])
+        low = jnp.concatenate([space.low for space in spaces])
+        high = jnp.concatenate([space.high for space in spaces])
         return BoxSpace(low=low, high=high)
 
     def sample(self, generator: Generator) -> Any:
diff --git a/src/emevo/status.py b/src/emevo/status.py
index 22d53b26..f10ff4d2 100644
--- a/src/emevo/status.py
+++ b/src/emevo/status.py
@@ -1,32 +1,31 @@
 from __future__ import annotations
 
-import dataclasses
+import chex
 from typing import Any
 
-from typing_extensions import Self
+import jax
+from emevo.types import Self
+import jax.numpy as jnp
 
-
-@dataclasses.dataclass
+@chex.dataclass
 class Status:
     """Default status implementation with age and energy."""
 
-    age: float
-    energy: float
+    age: jax.Array
+    energy: jax.Array
     capacity: float = 100.0
     metadata: dict[str, Any] | None = None
 
-    def step(self) -> None:
+    def step(self) -> Self:
         """Get older."""
-        self.age += 1
+        return self.replace(age=self.age + 1)
 
-    def share(self, ratio: float) -> float:
+    def share(self, ratio: float) -> tuple[Self, jax.Array]:
         """Share some portion of energy."""
         shared = self.energy * ratio
-        self.update(energy_delta=-shared)
-        return shared
+        return self.update(energy_delta=-shared), shared
 
-    def update(self, *, energy_delta: float) -> Self:
+    def update(self, *, energy_delta: jax.Array) -> Self:
         """Update energy."""
         energy = self.energy + energy_delta
-        self.energy = min(max(0.0, energy), self.capacity)
-        return self
+        return self.replace(energy=jnp.clip(energy, a_min=0.0, a_max=self.capacity))
diff --git a/src/emevo/types.py b/src/emevo/types.py
new file mode 100644
index 00000000..edce5b48
--- /dev/null
+++ b/src/emevo/types.py
@@ -0,0 +1,17 @@
+from typing import Any, Protocol, Sequence
+
+import jax
+
+DType = jax.numpy.dtype
+
+
+class SupportsDType(Protocol):
+    @property
+    def dtype(self) -> DType:
+        ...
+
+
+DTypeLike = DType | SupportsDType
+PyTree = Any
+Self = Any
+Index = int | jax.Array | Sequence[int]

From 2731e3196ffa3a9e9ed5557bccfc9f4a7f0134cc Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 26 Sep 2023 18:35:27 +0900
Subject: [PATCH 002/337] Phyjax

---
 src/emevo/__init__.py              |   3 +-
 src/emevo/environments/phyjax2d.py | 945 +++++++++++++++++++++++++++++
 src/emevo/spaces.py                |  83 +--
 src/emevo/types.py                 |   3 +-
 4 files changed, 991 insertions(+), 43 deletions(-)
 create mode 100644 src/emevo/environments/phyjax2d.py

diff --git a/src/emevo/__init__.py b/src/emevo/__init__.py
index 93fc558f..0b11d603 100644
--- a/src/emevo/__init__.py
+++ b/src/emevo/__init__.py
@@ -4,8 +4,7 @@
 """
 
 
-from emevo.body import Body, Encount, Profile
-from emevo.env import Env
+from emevo.env import Profile, Env
 from emevo.environments import make, register
 from emevo.status import Status
 
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
new file mode 100644
index 00000000..8e67d5cd
--- /dev/null
+++ b/src/emevo/environments/phyjax2d.py
@@ -0,0 +1,945 @@
+import functools
+from collections.abc import Sequence
+from typing import Any, Callable, Protocol
+
+import chex
+import jax
+import jax.numpy as jnp
+
+Axis = Sequence[int] | int
+Self = Any
+
+
+def safe_norm(x: jax.Array, axis: Axis | None = None) -> jax.Array:
+    is_zero = jnp.allclose(x, 0.0)
+    x = jnp.where(is_zero, jnp.ones_like(x), x)
+    n = jnp.linalg.norm(x, axis=axis)
+    return jnp.where(is_zero, 0.0, n)  # pyright: ignore
+
+
+def normalize(x: jax.Array, axis: Axis | None = None) -> tuple[jax.Array, jax.Array]:
+    norm = safe_norm(x, axis=axis)
+    n = x / (norm + 1e-6 * (norm == 0.0))
+    return n, norm
+
+
+def tree_map2(
+    f: Callable[..., Any],
+    tree: Any,
+    *rest: Any,
+    is_leaf: Callable[[Any], bool] | None = None,
+) -> tuple[Any, Any]:
+    """Same as tree_map, but returns a tuple"""
+    leaves, treedef = jax.tree_util.tree_flatten(tree, is_leaf)
+    all_leaves = [leaves] + [treedef.flatten_up_to(r) for r in rest]
+    result = [f(*xs) for xs in zip(*all_leaves)]
+    a = treedef.unflatten([elem[0] for elem in result])
+    b = treedef.unflatten([elem[1] for elem in result])
+    return a, b
+
+
+def generate_self_pairs(x: jax.Array) -> tuple[jax.Array, jax.Array]:
+    """Returns two arrays that iterate over all combination of elements in x and y."""
+    # x.shape[0] > 1
+    chex.assert_axis_dimension_gt(x, 0, 1)
+    n = x.shape[0]
+    # (a, a, a, b, b, c)
+    outer_loop = jnp.repeat(
+        x,
+        jnp.arange(n - 1, -1, -1),
+        axis=0,
+        total_repeat_length=n * (n - 1) // 2,
+    )
+    # (b, c, d, c, d, d)
+    inner_loop = jnp.concatenate([x[i:] for i in range(1, len(x))])
+    return outer_loop, inner_loop
+
+
+def _pair_outer(x: jax.Array, reps: int) -> jax.Array:
+    return jnp.repeat(x, reps, axis=0, total_repeat_length=x.shape[0] * reps)
+
+
+def _pair_inner(x: jax.Array, reps: int) -> jax.Array:
+    return jnp.tile(x, (reps,) + (1,) * (x.ndim - 1))
+
+
+def generate_pairs(x: jax.Array, y: jax.Array) -> tuple[jax.Array, jax.Array]:
+    """Returns two arrays that iterate over all combination of elements in x and y"""
+    xlen, ylen = x.shape[0], y.shape[0]
+    return _pair_outer(x, ylen), _pair_inner(y, xlen)
+
+
+class PyTreeOps:
+    def __add__(self, o: Any) -> Self:
+        if o.__class__ is self.__class__:
+            return jax.tree_map(lambda x, y: x + y, self, o)
+        else:
+            return jax.tree_map(lambda x: x + o, self)
+
+    def __sub__(self, o: Any) -> Self:
+        if o.__class__ is self.__class__:
+            return jax.tree_map(lambda x, y: x - y, self, o)
+        else:
+            return jax.tree_map(lambda x: x - o, self)
+
+    def __mul__(self, o: float | jax.Array) -> Self:
+        return jax.tree_map(lambda x: x * o, self)
+
+    def __neg__(self) -> Self:
+        return jax.tree_map(lambda x: -x, self)
+
+    def __truediv__(self, o: float | jax.Array) -> Self:
+        return jax.tree_map(lambda x: x / o, self)
+
+    def get_slice(
+        self,
+        index: int | Sequence[int] | Sequence[bool] | jax.Array,
+    ) -> Self:
+        return jax.tree_map(lambda x: x[index], self)
+
+    def reshape(self, shape: Sequence[int]) -> Self:
+        return jax.tree_map(lambda x: x.reshape(shape), self)
+
+    def sum(self, axis: int | None = None) -> Self:
+        return jax.tree_map(lambda x: jnp.sum(x, axis=axis), self)
+
+    def tolist(self) -> list[Self]:
+        leaves, treedef = jax.tree_util.tree_flatten(self)
+        return [treedef.unflatten(leaf) for leaf in zip(*leaves)]
+
+    def zeros_like(self) -> Any:
+        return jax.tree_map(lambda x: jnp.zeros_like(x), self)
+
+    @property
+    def shape(self) -> Any:
+        """For debugging"""
+        return jax.tree_map(lambda x: x.shape, self)
+
+
+TWO_PI = jnp.pi * 2
+
+
+class _PositionLike(Protocol):
+    angle: jax.Array  # Angular velocity (N,)
+    xy: jax.Array  # (N, 2)
+
+    def __init__(self, angle: jax.Array, xy: jax.Array) -> Self:
+        ...
+
+    def batch_size(self) -> int:
+        return self.angle.shape[0]
+
+    @classmethod
+    def zeros(cls: type[Self], n: int) -> Self:
+        return cls(angle=jnp.zeros((n,)), xy=jnp.zeros((n, 2)))
+
+
+@chex.dataclass
+class Velocity(_PositionLike, PyTreeOps):
+    angle: jax.Array  # Angular velocity (N,)
+    xy: jax.Array  # (N, 2)
+
+
+@chex.dataclass
+class Force(_PositionLike, PyTreeOps):
+    angle: jax.Array  # Angular (torque) force (N,)
+    xy: jax.Array  # (N, 2)
+
+
+def _get_xy(xy: jax.Array) -> tuple[jax.Array, jax.Array]:
+    x = jax.lax.slice_in_dim(xy, 0, 1, axis=-1)
+    y = jax.lax.slice_in_dim(xy, 1, 2, axis=-1)
+    return jax.lax.squeeze(x, (-1,)), jax.lax.squeeze(y, (-1,))
+
+
+@chex.dataclass
+class Position(_PositionLike, PyTreeOps):
+    angle: jax.Array  # Angular velocity (N, 1)
+    xy: jax.Array  # (N, 2)
+
+    def rotate(self, xy: jax.Array) -> jax.Array:
+        x, y = _get_xy(xy)
+        s, c = jnp.sin(self.angle), jnp.cos(self.angle)
+        rot_x = c * x - s * y
+        rot_y = s * x + c * y
+        return jnp.stack((rot_x, rot_y), axis=-1)
+
+    def transform(self, xy: jax.Array) -> jax.Array:
+        return self.rotate(xy) + self.xy
+
+    def inv_rotate(self, xy: jax.Array) -> jax.Array:
+        x, y = _get_xy(xy)
+        s, c = jnp.sin(self.angle), jnp.cos(self.angle)
+        rot_x = c * x + s * y
+        rot_y = c * y - s * x
+        return jnp.stack((rot_x, rot_y), axis=-1)
+
+    def inv_transform(self, xy: jax.Array) -> jax.Array:
+        return self.inv_rotate(xy - self.xy)
+
+
+@chex.dataclass
+class Shape(PyTreeOps):
+    mass: jax.Array
+    moment: jax.Array
+    elasticity: jax.Array
+    friction: jax.Array
+    rgba: jax.Array
+
+    def inv_mass(self) -> jax.Array:
+        """To support static shape, set let inv_mass 0 if mass is infinite"""
+        m = self.mass
+        return jnp.where(jnp.isfinite(m), 1.0 / m, jnp.zeros_like(m))
+
+    def inv_moment(self) -> jax.Array:
+        """As inv_mass does, set inv_moment 0 if moment is infinite"""
+        m = self.moment
+        return jnp.where(jnp.isfinite(m), 1.0 / m, jnp.zeros_like(m))
+
+    def to_shape(self) -> Self:
+        return Shape(
+            mass=self.mass,
+            moment=self.moment,
+            elasticity=self.elasticity,
+            friction=self.friction,
+            rgba=self.rgba,
+        )
+
+
+@chex.dataclass
+class Circle(Shape):
+    radius: jax.Array
+
+
+@chex.dataclass
+class State(PyTreeOps):
+    p: Position
+    v: Velocity
+    f: Force
+    is_active: jax.Array
+
+
+@chex.dataclass
+class Contact(PyTreeOps):
+    pos: jax.Array
+    normal: jax.Array
+    penetration: jax.Array
+    elasticity: jax.Array
+    friction: jax.Array
+
+    def contact_dim(self) -> int:
+        return self.pos.shape[1]
+
+
+@jax.vmap
+def _circle_to_circle_impl(
+    a: Circle,
+    b: Circle,
+    a_pos: Position,
+    b_pos: Position,
+    isactive: jax.Array,
+) -> Contact:
+    a2b_normal, dist = normalize(b_pos.xy - a_pos.xy)
+    penetration = a.radius + b.radius - dist
+    a_contact = a_pos.xy + a2b_normal * a.radius
+    b_contact = b_pos.xy - a2b_normal * b.radius
+    pos = (a_contact + b_contact) * 0.5
+    # Filter penetration
+    penetration = jnp.where(isactive, penetration, jnp.ones_like(penetration) * -1)
+    return Contact(
+        pos=pos,
+        normal=a2b_normal,
+        penetration=penetration,
+        elasticity=(a.elasticity + b.elasticity) * 0.5,
+        friction=(a.friction + b.friction) * 0.5,
+    )
+
+
+@chex.dataclass
+class ContactHelper:
+    tangent: jax.Array
+    mass_normal: jax.Array
+    mass_tangent: jax.Array
+    v_bias: jax.Array
+    bounce: jax.Array
+    r1: jax.Array
+    r2: jax.Array
+    inv_mass1: jax.Array
+    inv_mass2: jax.Array
+    inv_moment1: jax.Array
+    inv_moment2: jax.Array
+    local_anchor1: jax.Array
+    local_anchor2: jax.Array
+    allow_bounce: jax.Array
+
+
+@chex.dataclass
+class VelocitySolver:
+    v1: Velocity
+    v2: Velocity
+    pn: jax.Array
+    pt: jax.Array
+    contact: jax.Array
+
+    def update(self, new_contact: jax.Array) -> Self:
+        continuing_contact = jnp.logical_and(self.contact, new_contact)
+        pn = jnp.where(continuing_contact, self.pn, jnp.zeros_like(self.pn))
+        pt = jnp.where(continuing_contact, self.pt, jnp.zeros_like(self.pt))
+        return self.replace(pn=pn, pt=pt, contact=new_contact)
+
+
+def init_solver(n: int) -> VelocitySolver:
+    return VelocitySolver(
+        v1=Velocity.zeros(n),
+        v2=Velocity.zeros(n),
+        pn=jnp.zeros(n),
+        pt=jnp.zeros(n),
+        contact=jnp.zeros(n, dtype=bool),
+    )
+
+
+def _pv_gather(
+    p1: _PositionLike,
+    p2: _PositionLike,
+    orig: _PositionLike,
+) -> _PositionLike:
+    indices = jnp.arange(len(orig.angle))
+    outer, inner = generate_self_pairs(indices)
+    p1_xy = jnp.zeros_like(orig.xy).at[outer].add(p1.xy)
+    p1_angle = jnp.zeros_like(orig.angle).at[outer].add(p1.angle)
+    p2_xy = jnp.zeros_like(orig.xy).at[inner].add(p2.xy)
+    p2_angle = jnp.zeros_like(orig.angle).at[inner].add(p2.angle)
+    return p1.__class__(xy=p1_xy + p2_xy, angle=p1_angle + p2_angle)
+
+
+def _vmap_dot(xy1: jax.Array, xy2: jax.Array) -> jax.Array:
+    """Dot product between nested vectors"""
+    chex.assert_equal_shape((xy1, xy2))
+    orig_shape = xy1.shape
+    a = xy1.reshape(-1, orig_shape[-1])
+    b = xy2.reshape(-1, orig_shape[-1])
+    return jax.vmap(jnp.dot, in_axes=(0, 0))(a, b).reshape(*orig_shape[:-1])
+
+
+def _sv_cross(s: jax.Array, v: jax.Array) -> jax.Array:
+    """Cross product with scalar and vector"""
+    x, y = _get_xy(v)
+    return jnp.stack((y * -s, x * s), axis=-1)
+
+
+def _dv2from1(v1: Velocity, r1: jax.Array, v2: Velocity, r2: jax.Array) -> jax.Array:
+    """Compute relative veclotiy from v2/r2 to v1/r1"""
+    rel_v1 = v1.xy + _sv_cross(v1.angle, r1)
+    rel_v2 = v2.xy + _sv_cross(v2.angle, r2)
+    return rel_v2 - rel_v1
+
+
+def _effective_mass(
+    inv_mass: jax.Array,
+    inv_moment: jax.Array,
+    r: jax.Array,
+    n: jax.Array,
+) -> jax.Array:
+    rn2 = jnp.cross(r, n) ** 2
+    return inv_mass + inv_moment * rn2
+
+
+@chex.dataclass
+class Capsule(Shape):
+    length: jax.Array
+    radius: jax.Array
+
+
+@chex.dataclass
+class Segment(Shape):
+    length: jax.Array
+
+    def to_capsule(self) -> Capsule:
+        return Capsule(
+            mass=self.mass,
+            moment=self.moment,
+            elasticity=self.elasticity,
+            friction=self.friction,
+            rgba=self.rgba,
+            length=self.length,
+            radius=jnp.zeros_like(self.length),
+        )
+
+
+def _length_to_points(length: jax.Array) -> tuple[jax.Array, jax.Array]:
+    a = jnp.stack((length * -0.5, length * 0.0), axis=-1)
+    b = jnp.stack((length * 0.5, length * 0.0), axis=-1)
+    return a, b
+
+
+@jax.vmap
+def _capsule_to_circle_impl(
+    a: Capsule,
+    b: Circle,
+    a_pos: Position,
+    b_pos: Position,
+    isactive: jax.Array,
+) -> Contact:
+    # Move b_pos to capsule's coordinates
+    pb = a_pos.inv_transform(b_pos.xy)
+    p1, p2 = _length_to_points(a.length)
+    edge = p2 - p1
+    s1 = jnp.dot(pb - p1, edge)
+    s2 = jnp.dot(p2 - pb, edge)
+    in_segment = jnp.logical_and(s1 >= 0.0, s2 >= 0.0)
+    ee = jnp.sum(jnp.square(edge), axis=-1, keepdims=True)
+    # Closest point
+    # s1 < 0: pb is left to the capsule
+    # s2 < 0: pb is right to the capsule
+    # else: pb is in between capsule
+    pa = jax.lax.select(
+        in_segment,
+        p1 + edge * s1 / ee,
+        jax.lax.select(s1 < 0.0, p1, p2),
+    )
+    a2b_normal, dist = normalize(pb - pa)
+    penetration = a.radius + b.radius - dist
+    a_contact = pa + a2b_normal * a.radius
+    b_contact = pb - a2b_normal * b.radius
+    pos = a_pos.transform((a_contact + b_contact) * 0.5)
+    xy_zeros = jnp.zeros_like(b_pos.xy)
+    a2b_normal_rotated = a_pos.replace(xy=xy_zeros).transform(a2b_normal)
+    # Filter penetration
+    penetration = jnp.where(isactive, penetration, jnp.ones_like(penetration) * -1)
+    return Contact(
+        pos=pos,
+        normal=a2b_normal_rotated,
+        penetration=penetration,
+        elasticity=(a.elasticity + b.elasticity) * 0.5,
+        friction=(a.friction + b.friction) * 0.5,
+    )
+
+
+@chex.dataclass
+class ShapeDict:
+    circle: Circle | None = None
+    segment: Segment | None = None
+    capsule: Capsule | None = None
+
+    def concat(self) -> Shape:
+        shapes = [s.to_shape() for s in self.values() if s is not None]
+        return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *shapes)
+
+
+@chex.dataclass
+class StateDict:
+    circle: State | None = None
+    segment: State | None = None
+    capsule: State | None = None
+
+    def concat(self) -> None:
+        states = [s for s in self.values() if s is not None]
+        return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *states)
+
+    def offset(self, key: str) -> int:
+        total = 0
+        for k, state in self.items():
+            if k == key:
+                return total
+            if state is not None:
+                total += state.p.batch_size()
+        raise RuntimeError("Unreachable")
+
+    def _get(self, name: str, state: State) -> State | None:
+        if self[name] is None:
+            return None
+        else:
+            start = self.offset(name)
+            end = start + self[name].p.batch_size()
+            return state.get_slice(jnp.arange(start, end))
+
+    def update(self, statec: State) -> Self:
+        circle = self._get("circle", statec)
+        segment = self._get("segment", statec)
+        capsule = self._get("capsule", statec)
+        return self.__class__(circle=circle, segment=segment, capsule=capsule)
+
+
+def _circle_to_circle(
+    shaped: ShapeDict,
+    stated: StateDict,
+) -> tuple[Contact, Circle, Circle]:
+    circle1, circle2 = tree_map2(generate_self_pairs, shaped.circle)
+    pos1, pos2 = tree_map2(generate_self_pairs, stated.circle.p)
+    is_active = jnp.logical_and(*generate_self_pairs(stated.circle.is_active))
+    contacts = _circle_to_circle_impl(
+        circle1,
+        circle2,
+        pos1,
+        pos2,
+        is_active,
+    )
+    return contacts, circle1, circle2
+
+
+def _capsule_to_circle(
+    shaped: ShapeDict,
+    stated: StateDict,
+) -> tuple[Contact, Capsule, Circle]:
+    capsule = jax.tree_map(
+        functools.partial(_pair_outer, reps=shaped.circle.mass.shape[0]),
+        shaped.capsule,
+    )
+    circle = jax.tree_map(
+        functools.partial(_pair_inner, reps=shaped.capsule.mass.shape[0]),
+        shaped.circle,
+    )
+    pos1, pos2 = tree_map2(generate_pairs, stated.capsule.p, stated.circle.p)
+    is_active = jnp.logical_and(
+        *generate_pairs(stated.capsule.is_active, stated.circle.is_active)
+    )
+    contacts = _capsule_to_circle_impl(
+        capsule,
+        circle,
+        pos1,
+        pos2,
+        is_active,
+    )
+    return contacts, capsule, circle
+
+
+def _segment_to_circle(
+    shaped: ShapeDict,
+    stated: StateDict,
+) -> tuple[Contact, Segment, Circle]:
+    segment = jax.tree_map(
+        functools.partial(_pair_outer, reps=shaped.circle.mass.shape[0]),
+        shaped.segment,
+    )
+    circle = jax.tree_map(
+        functools.partial(_pair_inner, reps=shaped.segment.mass.shape[0]),
+        shaped.circle,
+    )
+    pos1, pos2 = tree_map2(generate_pairs, stated.segment.p, stated.circle.p)
+    is_active = jnp.logical_and(
+        *generate_pairs(stated.segment.is_active, stated.circle.is_active)
+    )
+    contacts = _capsule_to_circle_impl(
+        segment.to_capsule(),
+        circle,
+        pos1,
+        pos2,
+        is_active,
+    )
+    return contacts, segment, circle
+
+
+_CONTACT_FUNCTIONS = {
+    ("circle", "circle"): _circle_to_circle,
+    ("capsule", "circle"): _capsule_to_circle,
+    ("segment", "circle"): _segment_to_circle,
+}
+
+
+@chex.dataclass
+class ContactWithMetadata:
+    contact: Contact
+    shape1: Shape
+    shape2: Shape
+    outer_index: jax.Array
+    inner_index: jax.Array
+
+    def gather_p_or_v(
+        self,
+        outer: _PositionLike,
+        inner: _PositionLike,
+        orig: _PositionLike,
+    ) -> _PositionLike:
+        xy_outer = jnp.zeros_like(orig.xy).at[self.outer_index].add(outer.xy)
+        angle_outer = jnp.zeros_like(orig.angle).at[self.outer_index].add(outer.angle)
+        xy_inner = jnp.zeros_like(orig.xy).at[self.inner_index].add(inner.xy)
+        angle_inner = jnp.zeros_like(orig.angle).at[self.inner_index].add(inner.angle)
+        return orig.__class__(angle=angle_outer + angle_inner, xy=xy_outer + xy_inner)
+
+
+@chex.dataclass
+class Space:
+    gravity: jax.Array
+    shaped: ShapeDict
+    dt: jax.Array | float = 0.1
+    linear_damping: jax.Array | float = 0.95
+    angular_damping: jax.Array | float = 0.95
+    bias_factor: jax.Array | float = 0.2
+    n_velocity_iter: int = 8
+    n_position_iter: int = 2
+    linear_slop: jax.Array | float = 0.005
+    max_linear_correction: jax.Array | float = 0.2
+    allowed_penetration: jax.Array | float = 0.005
+    bounce_threshold: float = 1.0
+
+    def check_contacts(self, stated: StateDict) -> ContactWithMetadata:
+        contacts = []
+        for (n1, n2), fn in _CONTACT_FUNCTIONS.items():
+            if stated[n1] is not None and stated[n2] is not None:
+                contact, shape1, shape2 = fn(self.shaped, stated)
+                len1, len2 = stated[n1].p.batch_size(), stated[n2].p.batch_size()
+                offset1, offset2 = stated.offset(n1), stated.offset(n2)
+                if n1 == n2:
+                    outer_index, inner_index = generate_self_pairs(jnp.arange(len1))
+                else:
+                    outer_index, inner_index = generate_pairs(
+                        jnp.arange(len1),
+                        jnp.arange(len2),
+                    )
+                contact_with_meta = ContactWithMetadata(
+                    contact=contact,
+                    shape1=shape1.to_shape(),
+                    shape2=shape2.to_shape(),
+                    outer_index=outer_index + offset1,
+                    inner_index=inner_index + offset2,
+                )
+                contacts.append(contact_with_meta)
+        return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *contacts)
+
+    def n_possible_contacts(self) -> int:
+        n = 0
+        for n1, n2 in _CONTACT_FUNCTIONS.keys():
+            if self.shaped[n1] is not None and self.shaped[n2] is not None:
+                len1, len2 = len(self.shaped[n1].mass), len(self.shaped[n2].mass)
+                if n1 == n2:
+                    n += len1 * (len1 - 1) // 2
+                else:
+                    n += len1 * len2
+        return n
+
+
+def update_velocity(space: Space, shape: Shape, state: State) -> State:
+    # Expand (N, ) to (N, 1) because xy has a shape (N, 2)
+    invm = jnp.expand_dims(shape.inv_mass(), axis=1)
+    gravity = jnp.where(
+        jnp.logical_and(invm > 0, jnp.expand_dims(state.is_active, axis=1)),
+        space.gravity * jnp.ones_like(state.v.xy),
+        jnp.zeros_like(state.v.xy),
+    )
+    v_xy = state.v.xy + (gravity + state.f.xy * invm) * space.dt
+    v_ang = state.v.angle + state.f.angle * shape.inv_moment() * space.dt
+    # Damping: dv/dt + vc = 0 -> v(t) = v0 * exp(-tc)
+    # v(t + dt) = v0 * exp(-tc - dtc) = v0 * exp(-tc) * exp(-dtc) = v(t)exp(-dtc)
+    # Thus, linear/angular damping factors are actually exp(-dtc)
+    return state.replace(
+        v=Velocity(angle=v_ang * space.angular_damping, xy=v_xy * space.linear_damping),
+        f=state.f.zeros_like(),
+    )
+
+
+def update_position(space: Space, state: State) -> State:
+    v_dt = state.v * space.dt
+    xy = state.p.xy + v_dt.xy
+    angle = (state.p.angle + v_dt.angle + TWO_PI) % TWO_PI
+    return state.replace(p=Position(angle=angle, xy=xy))
+
+
+def init_contact_helper(
+    space: Space,
+    contact: Contact,
+    a: Shape,
+    b: Shape,
+    p1: Position,
+    p2: Position,
+    v1: Velocity,
+    v2: Velocity,
+) -> ContactHelper:
+    r1 = contact.pos - p1.xy
+    r2 = contact.pos - p2.xy
+
+    inv_mass1, inv_mass2 = a.inv_mass(), b.inv_mass()
+    inv_moment1, inv_moment2 = a.inv_moment(), b.inv_moment()
+    kn1 = _effective_mass(inv_mass1, inv_moment1, r1, contact.normal)
+    kn2 = _effective_mass(inv_mass2, inv_moment2, r2, contact.normal)
+    nx, ny = _get_xy(contact.normal)
+    tangent = jnp.stack((-ny, nx), axis=-1)
+    kt1 = _effective_mass(inv_mass1, inv_moment1, r1, tangent)
+    kt2 = _effective_mass(inv_mass2, inv_moment2, r2, tangent)
+    clipped_p = jnp.clip(space.allowed_penetration - contact.penetration, a_max=0.0)
+    v_bias = -space.bias_factor / space.dt * clipped_p
+    # k_normal, k_tangent, and v_bias should have (N(N-1)/2, N_contacts) shape
+    chex.assert_equal_shape((contact.friction, kn1, kn2, kt1, kt2, v_bias))
+    # Compute elasiticity * relative_vel
+    dv = _dv2from1(v1, r1, v2, r2)
+    vn = _vmap_dot(dv, contact.normal)
+    return ContactHelper(
+        tangent=tangent,
+        mass_normal=1 / (kn1 + kn2),
+        mass_tangent=1 / (kt1 + kt2),
+        v_bias=v_bias,
+        bounce=vn * contact.elasticity,
+        r1=r1,
+        r2=r2,
+        inv_mass1=inv_mass1,
+        inv_mass2=inv_mass2,
+        inv_moment1=inv_moment1,
+        inv_moment2=inv_moment2,
+        local_anchor1=p1.inv_rotate(r1),
+        local_anchor2=p2.inv_rotate(r2),
+        allow_bounce=vn <= -space.bounce_threshold,
+    )
+
+
+@jax.vmap
+def apply_initial_impulse(
+    contact: Contact,
+    helper: ContactHelper,
+    solver: VelocitySolver,
+) -> VelocitySolver:
+    """Warm starting by applying initial impulse"""
+    p = helper.tangent * solver.pt + contact.normal * solver.pn
+    v1 = solver.v1 - Velocity(
+        angle=helper.inv_moment1 * jnp.cross(helper.r1, p),
+        xy=p * helper.inv_mass1,
+    )
+    v2 = solver.v2 + Velocity(
+        angle=helper.inv_moment2 * jnp.cross(helper.r2, p),
+        xy=p * helper.inv_mass2,
+    )
+    return solver.replace(v1=v1, v2=v2)
+
+
+@jax.vmap
+def apply_velocity_normal(
+    contact: Contact,
+    helper: ContactHelper,
+    solver: VelocitySolver,
+) -> VelocitySolver:
+    """
+    Apply velocity constraints to the solver.
+    Suppose that each shape has (N_contact, 1) or (N_contact, 2).
+    """
+    # Relative veclocity (from shape2 to shape1)
+    dv = _dv2from1(solver.v1, helper.r1, solver.v2, helper.r2)
+    vt = jnp.dot(dv, helper.tangent)
+    dpt = -helper.mass_tangent * vt
+    # Clamp friction impulse
+    max_pt = contact.friction * solver.pn
+    pt = jnp.clip(solver.pt + dpt, a_min=-max_pt, a_max=max_pt)
+    dpt_clamped = helper.tangent * (pt - solver.pt)
+    # Velocity update by contact tangent
+    dvt1 = Velocity(
+        angle=-helper.inv_moment1 * jnp.cross(helper.r1, dpt_clamped),
+        xy=-dpt_clamped * helper.inv_mass1,
+    )
+    dvt2 = Velocity(
+        angle=helper.inv_moment2 * jnp.cross(helper.r2, dpt_clamped),
+        xy=dpt_clamped * helper.inv_mass2,
+    )
+    # Compute Relative velocity again
+    dv = _dv2from1(solver.v1 + dvt1, helper.r1, solver.v2 + dvt2, helper.r2)
+    vn = _vmap_dot(dv, contact.normal)
+    dpn = helper.mass_normal * (-vn + helper.v_bias)
+    # Accumulate and clamp impulse
+    pn = jnp.clip(solver.pn + dpn, a_min=0.0)
+    dpn_clamped = contact.normal * (pn - solver.pn)
+    # Velocity update by contact normal
+    dvn1 = Velocity(
+        angle=-helper.inv_moment1 * jnp.cross(helper.r1, dpn_clamped),
+        xy=-dpn_clamped * helper.inv_mass1,
+    )
+    dvn2 = Velocity(
+        angle=helper.inv_moment2 * jnp.cross(helper.r2, dpn_clamped),
+        xy=dpn_clamped * helper.inv_mass2,
+    )
+    # Filter dv
+    dv1, dv2 = jax.tree_map(
+        lambda x: jnp.where(solver.contact, x, jnp.zeros_like(x)),
+        (dvn1 + dvt1, dvn2 + dvt2),
+    )
+    # Summing up dv per each contact pair
+    return VelocitySolver(
+        v1=dv1,
+        v2=dv2,
+        pn=pn,
+        pt=pt,
+        contact=solver.contact,
+    )
+
+
+@jax.vmap
+def apply_bounce(
+    contact: Contact,
+    helper: ContactHelper,
+    solver: VelocitySolver,
+) -> tuple[Velocity, Velocity]:
+    """
+    Apply bounce (resititution).
+    Suppose that each shape has (N_contact, 1) or (N_contact, 2).
+    """
+    # Relative veclocity (from shape2 to shape1)
+    dv = _dv2from1(solver.v1, helper.r1, solver.v2, helper.r2)
+    vn = jnp.dot(dv, contact.normal)
+    pn = -helper.mass_normal * (vn + helper.bounce)
+    dpn = contact.normal * pn
+    # Velocity update by contact normal
+    dv1 = Velocity(
+        angle=-helper.inv_moment1 * jnp.cross(helper.r1, dpn),
+        xy=-dpn * helper.inv_mass1,
+    )
+    dv2 = Velocity(
+        angle=helper.inv_moment2 * jnp.cross(helper.r2, dpn),
+        xy=dpn * helper.inv_mass2,
+    )
+    # Filter dv
+    allow_bounce = jnp.logical_and(solver.contact, helper.allow_bounce)
+    return jax.tree_map(
+        lambda x: jnp.where(allow_bounce, x, jnp.zeros_like(x)),
+        (dv1, dv2),
+    )
+
+
+@chex.dataclass
+class PositionSolver:
+    p1: Position
+    p2: Position
+    contact: jax.Array
+    min_separation: jax.Array
+
+
+@functools.partial(jax.vmap, in_axes=(None, None, None, 0, 0, 0))
+def correct_position(
+    bias_factor: float | jax.Array,
+    linear_slop: float | jax.Array,
+    max_linear_correction: float | jax.Array,
+    contact: Contact,
+    helper: ContactHelper,
+    solver: PositionSolver,
+) -> PositionSolver:
+    """
+    Correct positions to remove penetration.
+    Suppose that each shape in contact and helper has (N_contact, 1) or (N_contact, 2).
+    p1 and p2 should have xy: (1, 2) angle (1, 1) shape
+    """
+    # (N_contact, 2)
+    r1 = solver.p1.rotate(helper.local_anchor1)
+    r2 = solver.p2.rotate(helper.local_anchor2)
+    ga2_ga1 = r2 - r1 + solver.p2.xy - solver.p1.xy
+    separation = jnp.dot(ga2_ga1, contact.normal) - contact.penetration
+    c = jnp.clip(
+        bias_factor * (separation + linear_slop),
+        a_min=-max_linear_correction,
+        a_max=0.0,
+    )
+    kn1 = _effective_mass(helper.inv_mass1, helper.inv_moment1, r1, contact.normal)
+    kn2 = _effective_mass(helper.inv_mass2, helper.inv_moment2, r2, contact.normal)
+    k_normal = kn1 + kn2
+    impulse = jnp.where(k_normal > 0.0, -c / k_normal, jnp.zeros_like(c))
+    pn = impulse * contact.normal
+    p1 = Position(
+        angle=-helper.inv_moment1 * jnp.cross(r1, pn),
+        xy=-pn * helper.inv_mass1,
+    )
+    p2 = Position(
+        angle=helper.inv_moment2 * jnp.cross(r2, pn),
+        xy=pn * helper.inv_mass2,
+    )
+    min_sep = jnp.fmin(solver.min_separation, separation)
+    # Filter separation
+    p1, p2 = jax.tree_map(
+        lambda x: jnp.where(solver.contact, x, jnp.zeros_like(x)),
+        (p1, p2),
+    )
+    return solver.replace(p1=p1, p2=p2, min_separation=min_sep)
+
+
+def solve_constraints(
+    space: Space,
+    solver: VelocitySolver,
+    p: Position,
+    v: Velocity,
+    contact_with_meta: ContactWithMetadata,
+) -> tuple[Velocity, Position, VelocitySolver]:
+    """Resolve collisions by Sequential Impulse method"""
+    outer, inner = contact_with_meta.outer_index, contact_with_meta.inner_index
+
+    def get_pairs(p_or_v: _PositionLike) -> tuple[_PositionLike, _PositionLike]:
+        return p_or_v.get_slice(outer), p_or_v.get_slice(inner)
+
+    p1, p2 = get_pairs(p)
+    v1, v2 = get_pairs(v)
+    helper = init_contact_helper(
+        space,
+        contact_with_meta.contact,
+        contact_with_meta.shape1,
+        contact_with_meta.shape2,
+        p1,
+        p2,
+        v1,
+        v2,
+    )
+    # Warm up the velocity solver
+    solver = apply_initial_impulse(
+        contact_with_meta.contact,
+        helper,
+        solver.replace(v1=v1, v2=v2),
+    )
+
+    def vstep(
+        _n_iter: int,
+        vs: tuple[Velocity, VelocitySolver],
+    ) -> tuple[Velocity, VelocitySolver]:
+        v_i, solver_i = vs
+        solver_i1 = apply_velocity_normal(contact_with_meta.contact, helper, solver_i)
+        v_i1 = contact_with_meta.gather_p_or_v(solver_i1.v1, solver_i1.v2, v_i) + v_i
+        v1, v2 = get_pairs(v_i1)
+        return v_i1, solver_i1.replace(v1=v1, v2=v2)
+
+    v, solver = jax.lax.fori_loop(0, space.n_velocity_iter, vstep, (v, solver))
+    bv1, bv2 = apply_bounce(contact_with_meta.contact, helper, solver)
+    v = contact_with_meta.gather_p_or_v(bv1, bv2, v) + v
+
+    def pstep(
+        _n_iter: int,
+        ps: tuple[Position, PositionSolver],
+    ) -> tuple[Position, PositionSolver]:
+        p_i, solver_i = ps
+        solver_i1 = correct_position(
+            space.bias_factor,
+            space.linear_slop,
+            space.max_linear_correction,
+            contact_with_meta.contact,
+            helper,
+            solver_i,
+        )
+        p_i1 = contact_with_meta.gather_p_or_v(solver_i1.p1, solver_i1.p2, p_i) + p_i
+        p1, p2 = get_pairs(p_i1)
+        return p_i1, solver_i1.replace(p1=p1, p2=p2)
+
+    pos_solver = PositionSolver(
+        p1=p1,
+        p2=p2,
+        contact=solver.contact,
+        min_separation=jnp.zeros_like(p1.angle),
+    )
+    p, pos_solver = jax.lax.fori_loop(0, space.n_position_iter, pstep, (p, pos_solver))
+    return v, p, solver
+
+
+def dont_solve_constraints(
+    _space: Space,
+    solver: VelocitySolver,
+    p: Position,
+    v: Velocity,
+    _contact_with_meta: ContactWithMetadata,
+) -> tuple[Velocity, Position, VelocitySolver]:
+    return v, p, solver
+
+
+def step(space: Space, stated: StateDict, solver: VelocitySolver) -> StateDict:
+    state = update_velocity(space, space.shaped.concat(), stated.concat())
+    contact_with_meta = space.check_contacts(stated.update(state))
+    # Check there's any penetration
+    contacts = contact_with_meta.contact.penetration >= 0
+    v, p, solver = jax.lax.cond(
+        jnp.any(contacts),
+        solve_constraints,
+        dont_solve_constraints,
+        space,
+        solver.update(contacts),
+        state.p,
+        state.v,
+        contact_with_meta,
+    )
+    statec = update_position(space, state.replace(v=v, p=p))
+    return stated.update(statec)
diff --git a/src/emevo/spaces.py b/src/emevo/spaces.py
index bc81fafb..4bdd7ccd 100644
--- a/src/emevo/spaces.py
+++ b/src/emevo/spaces.py
@@ -2,7 +2,8 @@
 from __future__ import annotations
 
 import abc
-from typing import Any, Generic, Iterable, NamedTuple, Sequence, TypeVar
+from collections.abc import Iterable, Sequence
+from typing import Any, Generic, NamedTuple, TypeVar
 
 import chex
 import jax
@@ -67,9 +68,9 @@ def __init__(
         self.shape = shape
 
         # Capture the boundedness information before replacing jnp.inf with get_inf
-        _low = jnp.full(shape, low, dtype=float) if jnp.isscalar(low) else low
+        _low = jnp.full(shape, low, dtype=jnp.float32) if jnp.isscalar(low) else low
         self.bounded_below = -jnp.inf < _low  # type: ignore
-        _high = jnp.full(shape, high, dtype=float) if jnp.isscalar(high) else high
+        _high = jnp.full(shape, high, dtype=jnp.float32) if jnp.isscalar(high) else high
         self.bounded_above = jnp.inf > _high  # type: ignore
 
         low = _broadcast(low, dtype, shape, inf_sign="-")  # type: ignore
@@ -87,8 +88,8 @@ def __init__(
         self.high_repr = _short_repr(self.high)
 
     def is_bounded(self, manner: str = "both") -> bool:
-        below = bool(jnp.all(self.bounded_below))
-        above = bool(jnp.all(self.bounded_above))
+        below = jnp.all(self.bounded_below).item()
+        above = jnp.all(self.bounded_above).item()
         if manner == "both":
             return below and above
         elif manner == "below":
@@ -105,41 +106,42 @@ def contains(self, x: jax.Array) -> bool:
         return bool(
             jnp.can_cast(x.dtype, self.dtype)
             and x.shape == self.shape
-            and jnp.all(x >= self.low)
-            and jnp.all(x <= self.high)
+            and jnp.all(x >= self.low).item()
+            and jnp.all(x <= self.high).item()
         )
 
     def flatten(self) -> BoxSpace:
         return BoxSpace(low=self.low.flatten(), high=self.high.flatten())
 
-    def sample(self, generator: Generator) -> jax.Array:
-        high = self.high if self.dtype.kind == "f" else self.high.astype("int64") + 1
-        sample = jnp.empty(self.shape)
-
-        # Masking arrays which classify the coordinates according to interval
-        # type
-        unbounded = ~self.bounded_below & ~self.bounded_above
-        upp_bounded = ~self.bounded_below & self.bounded_above
-        low_bounded = self.bounded_below & ~self.bounded_above
-        bounded = self.bounded_below & self.bounded_above
-
-        # Vectorized sampling by interval type
-        sample[unbounded] = generator.normal(size=unbounded[unbounded].shape)
-
-        sample[low_bounded] = (
-            generator.exponential(size=low_bounded[low_bounded].shape)
-            + self.low[low_bounded]
-        )
-        sample[upp_bounded] = (
-            -generator.exponential(size=upp_bounded[upp_bounded].shape)
-            + self.high[upp_bounded]
-        )
-        sample[bounded] = generator.uniform(
-            low=self.low[bounded], high=high[bounded], size=bounded[bounded].shape
+    def sample(self, key: chex.PRNGKey) -> jax.Array:
+        low = self.low.astype(jnp.float32)
+        if self.dtype.kind == "f":
+            high = self.high
+        else:
+            high = self.high.astype(jnp.float32) + 1.0
+        key1, key2, key3, key4 = jax.random.split(key, 4)
+        sample = jnp.where(
+            # Bounded
+            jnp.logical_and(self.bounded_below, self.bounded_above),
+            jax.random.uniform(key1, minval=low, maxval=high, shape=self.shape),
+            jnp.where(
+                self.bounded_below,
+                # Low bounded
+                low + jax.random.exponential(key2, shape=self.shape),
+                jnp.where(
+                    self.bounded_above,
+                    # High bounded
+                    high - jax.random.exponential(key3, shape=self.shape),
+                    # Unbounded
+                    jax.random.normal(key4, shape=self.shape),
+                ),
+            ),
         )
+
         if self.dtype.kind == "i":
-            sample = jnp.floor(sample)
-        return sample.astype(self.dtype)
+            return jnp.floor(sample).astype(self.dtype)
+        else:
+            return sample.astype(self.dtype)
 
     def normalize(self, normalized: jax.Array) -> jax.Array:
         range_ = self.high - self.low  # type: ignore
@@ -193,7 +195,7 @@ def _broadcast(
         value = get_inf(dtype, inf_sign) if jnp.isinf(value) else value  # type: ignore
         value = jnp.full(shape, value, dtype=dtype)
     else:
-        assert isinstance(value, jnp.ndarray)
+        assert isinstance(value, jax.Array)
         if jnp.any(jnp.isinf(value)):
             # create new array with dtype, but maintain old one to preserve jnp.inf
             temp = value.astype(dtype)
@@ -210,8 +212,8 @@ def __init__(self, n: int, start: int = 0) -> None:
         assert isinstance(start, (int, jnp.integer))
         self.dtype = jnp.dtype(int)
         self.shape = ()
-        self.n = int(n)
-        self.start = int(start)
+        self.n = n
+        self.start = start
 
     def clip(self, x: int) -> int:
         return min(max(0, x), self.n - 1)
@@ -231,8 +233,8 @@ def contains(self, x: int) -> bool:
     def flatten(self) -> BoxSpace:
         return BoxSpace(low=jnp.zeros(self.n), high=jnp.ones(self.n))
 
-    def sample(self, generator: Generator) -> int:
-        return int(self.start + generator.integers(self.n))
+    def sample(self, key: chex.PRNGKey) -> int:
+        return jax.random.randint(key, shape=(self.n,)) + self.start
 
     def __repr__(self) -> str:
         """Gives a string representation of this space."""
@@ -296,8 +298,9 @@ def flatten(self) -> BoxSpace:
         high = jnp.concatenate([space.high for space in spaces])
         return BoxSpace(low=low, high=high)
 
-    def sample(self, generator: Generator) -> Any:
-        samples = [space.sample(generator) for space in self.spaces]
+    def sample(self, key: chex.PRNGKey) -> int:
+        keys = jax.random.split(key, len(self.spaces))
+        samples = [space.sample(key) for space, key in zip(self.spaces, keys)]
         return self._cls(*samples)
 
     def __getitem__(self, key: str) -> Space:
diff --git a/src/emevo/types.py b/src/emevo/types.py
index edce5b48..f9ec1597 100644
--- a/src/emevo/types.py
+++ b/src/emevo/types.py
@@ -1,4 +1,5 @@
-from typing import Any, Protocol, Sequence
+from collections.abc import Sequence
+from typing import Any, Protocol
 
 import jax
 

From a88f73669c4d3facbb0442bf7f562161705559b6 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 27 Sep 2023 17:32:13 +0900
Subject: [PATCH 003/337] Space constructor

---
 src/emevo/environments/phyjax2d.py       |  62 ++++++----
 src/emevo/environments/phyjax2d_utils.py | 142 +++++++++++++++++++++++
 2 files changed, 184 insertions(+), 20 deletions(-)
 create mode 100644 src/emevo/environments/phyjax2d_utils.py

diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 8e67d5cd..40dae23f 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -10,6 +10,13 @@
 Self = Any
 
 
+def unwrap_or(x: Any, f: Callable[[Any], Any]) -> Any:
+    if x is None:
+        return x
+    else:
+        return f(x)
+
+
 def safe_norm(x: jax.Array, axis: Axis | None = None) -> jax.Array:
     is_zero = jnp.allclose(x, 0.0)
     x = jnp.where(is_zero, jnp.ones_like(x), x)
@@ -123,7 +130,7 @@ class _PositionLike(Protocol):
     angle: jax.Array  # Angular velocity (N,)
     xy: jax.Array  # (N, 2)
 
-    def __init__(self, angle: jax.Array, xy: jax.Array) -> Self:
+    def __init__(self, angle: jax.Array, xy: jax.Array) -> None:
         ...
 
     def batch_size(self) -> int:
@@ -218,6 +225,15 @@ class State(PyTreeOps):
     f: Force
     is_active: jax.Array
 
+    @staticmethod
+    def zeros(n: int) -> Self:
+        return State(
+            p=Position.zeros(n),
+            v=Velocity.zeros(n),
+            f=Force.zeros(n),
+            is_active=jnp.zeros(n),
+        )
+
 
 @chex.dataclass
 class Contact(PyTreeOps):
@@ -415,17 +431,6 @@ def _capsule_to_circle_impl(
     )
 
 
-@chex.dataclass
-class ShapeDict:
-    circle: Circle | None = None
-    segment: Segment | None = None
-    capsule: Capsule | None = None
-
-    def concat(self) -> Shape:
-        shapes = [s.to_shape() for s in self.values() if s is not None]
-        return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *shapes)
-
-
 @chex.dataclass
 class StateDict:
     circle: State | None = None
@@ -460,6 +465,23 @@ def update(self, statec: State) -> Self:
         return self.__class__(circle=circle, segment=segment, capsule=capsule)
 
 
+@chex.dataclass
+class ShapeDict:
+    circle: Circle | None = None
+    segment: Segment | None = None
+    capsule: Capsule | None = None
+
+    def concat(self) -> Shape:
+        shapes = [s.to_shape() for s in self.values() if s is not None]
+        return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *shapes)
+
+    def zeros_state(self) -> StateDict:
+        circle = unwrap_or(self.circle, lambda s: State.zeros(len(s.mass)))
+        segment = unwrap_or(self.segment, lambda s: State.zeros(len(s.mass)))
+        capsule = unwrap_or(self.capsule, lambda s: State.zeros(len(s.mass)))
+        return StateDict(circle=circle, segment=segment, capsule=capsule)
+
+
 def _circle_to_circle(
     shaped: ShapeDict,
     stated: StateDict,
@@ -561,15 +583,15 @@ def gather_p_or_v(
 class Space:
     gravity: jax.Array
     shaped: ShapeDict
-    dt: jax.Array | float = 0.1
-    linear_damping: jax.Array | float = 0.95
-    angular_damping: jax.Array | float = 0.95
-    bias_factor: jax.Array | float = 0.2
-    n_velocity_iter: int = 8
+    dt: float = 0.1
+    linear_damping: float = 0.95
+    angular_damping: float = 0.95
+    bias_factor: float = 0.2
+    n_velocity_iter: int = 6
     n_position_iter: int = 2
-    linear_slop: jax.Array | float = 0.005
-    max_linear_correction: jax.Array | float = 0.2
-    allowed_penetration: jax.Array | float = 0.005
+    linear_slop: float = 0.005
+    max_linear_correction: float = 0.2
+    allowed_penetration: float = 0.005
     bounce_threshold: float = 1.0
 
     def check_contacts(self, stated: StateDict) -> ContactWithMetadata:
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
new file mode 100644
index 00000000..fba8ec0f
--- /dev/null
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -0,0 +1,142 @@
+import dataclasses
+from typing import Any, NamedTuple
+
+import jax
+import jax.numpy as jnp
+
+from emevo.environments.phyjax2d import Capsule, Circle, Segment, ShapeDict, Space
+
+Self = Any
+
+
+class Color(NamedTuple):
+    r: int
+    g: int
+    b: int
+    a: int = 255
+
+    @staticmethod
+    def from_float(r: float, g: float, b: float, a: float = 1.0) -> Self:
+        return Color(int(r * 255), int(g * 255), int(b * 255), int(a * 255))
+
+    @staticmethod
+    def black() -> Self:
+        return Color(0, 0, 0, 255)
+
+
+_BLACK = Color.black()
+
+
+@dataclasses.dataclass
+class SpaceBuilder:
+    """
+    A convenient builder for creating a space.
+    Not expected to used with `jax.jit`.
+    """
+
+    gravity: tuple[float, float] = dataclasses.field(default=(0.0, -9.8))
+    circles: list[Circle] = dataclasses.field(default_factory=list)
+    capsules: list[Capsule] = dataclasses.field(default_factory=list)
+    segments: list[Segment] = dataclasses.field(default_factory=list)
+    dt: float = 0.1
+    linear_damping: float = 0.9
+    angular_damping: float = 0.9
+    bias_factor: float = 0.2
+    n_velocity_iter: int = 6
+    n_position_iter: int = 2
+    linear_slop: float = 0.005
+    max_linear_correction: float = 0.2
+    allowed_penetration: float = 0.005
+    bounce_threshold: float = 1.0
+
+    def add_circle(
+        self,
+        *,
+        radius: float,
+        mass: float,
+        moment: float,
+        elasticity: float,
+        rgba: Color = _BLACK,
+    ) -> None:
+        circle = Circle(
+            radius=jnp.array([radius]),
+            mass=jnp.array([mass]),
+            moment=jnp.array([moment]),
+            elasticity=jnp.array([elasticity]),
+            rgba=jnp.array(rgba).reshape(1, 4),
+        )
+        self.circles.append(circle)
+
+    def add_capsule(
+        self,
+        *,
+        length: float,
+        radius: float,
+        mass: float,
+        moment: float,
+        elasticity: float,
+        rgba: Color = _BLACK,
+    ) -> None:
+        capsule = Capsule(
+            length=jnp.array([length]),
+            radius=jnp.array([radius]),
+            mass=jnp.array([mass]),
+            moment=jnp.array([moment]),
+            elasticity=jnp.array([elasticity]),
+            rgba=jnp.array(rgba).reshape(1, 4),
+        )
+        self.capsules.append(capsule)
+
+    def add_segment(
+        self,
+        *,
+        length: float,
+        mass: float,
+        moment: float,
+        elasticity: float,
+        rgba: Color = _BLACK,
+    ) -> None:
+        segment = Segment(
+            length=jnp.array([length]),
+            mass=jnp.array([mass]),
+            moment=jnp.array([moment]),
+            elasticity=jnp.array([elasticity]),
+            rgba=jnp.array(rgba).reshape(1, 4),
+        )
+        self.segments.append(segment)
+
+    def build(self) -> Space:
+        if len(self.circles) > 0:
+            circle = jax.tree_map(lambda *args: jnp.stack(args), *self.circles)
+        else:
+            circle = None
+        if len(self.capsules) > 0:
+            capsule = jax.tree_map(lambda *args: jnp.stack(args), *self.capsules)
+        else:
+            capsule = None
+        if len(self.segments) > 0:
+            segment = jax.tree_map(lambda *args: jnp.stack(args), *self.segments)
+        else:
+            segment = None
+
+        shaped = ShapeDict(
+            circle=circle,
+            segment=segment,
+            capsule=capsule,
+        )
+        dt = self.dt
+        linear_damping = jnp.exp(-dt * self.linear_damping)
+        angular_damping = jnp.exp(-dt * self.angular_damping)
+        return Space(
+            gravity=jnp.array(self.gravity),
+            shaped=shaped,
+            linear_damping=linear_damping,
+            angular_damping=angular_damping,
+            bias_factor=self.bias_factor,
+            n_velocity_iter=self.n_velocity_iter,
+            n_position_iter=self.n_position_iter,
+            linear_slop=self.linear_slop,
+            max_linear_correction=self.max_linear_correction,
+            allowed_penetration=self.allowed_penetration,
+            bounce_threshold=self.bounce_threshold,
+        )

From 6d6a0362e5831bc5ec033d1f543e8472a3d935fd Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 28 Sep 2023 17:23:15 +0900
Subject: [PATCH 004/337] Compute mass and moment from density

---
 src/emevo/environments/phyjax2d.py       |   8 +-
 src/emevo/environments/phyjax2d_utils.py | 109 ++++++++++++++++-------
 2 files changed, 79 insertions(+), 38 deletions(-)

diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 40dae23f..41db1c5a 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -10,7 +10,7 @@
 Self = Any
 
 
-def unwrap_or(x: Any, f: Callable[[Any], Any]) -> Any:
+def then(x: Any, f: Callable[[Any], Any]) -> Any:
     if x is None:
         return x
     else:
@@ -476,9 +476,9 @@ def concat(self) -> Shape:
         return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *shapes)
 
     def zeros_state(self) -> StateDict:
-        circle = unwrap_or(self.circle, lambda s: State.zeros(len(s.mass)))
-        segment = unwrap_or(self.segment, lambda s: State.zeros(len(s.mass)))
-        capsule = unwrap_or(self.capsule, lambda s: State.zeros(len(s.mass)))
+        circle = then(self.circle, lambda s: State.zeros(len(s.mass)))
+        segment = then(self.segment, lambda s: State.zeros(len(s.mass)))
+        capsule = then(self.capsule, lambda s: State.zeros(len(s.mass)))
         return StateDict(circle=circle, segment=segment, capsule=capsule)
 
 
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index fba8ec0f..b41552c8 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -4,7 +4,14 @@
 import jax
 import jax.numpy as jnp
 
-from emevo.environments.phyjax2d import Capsule, Circle, Segment, ShapeDict, Space
+from emevo.environments.phyjax2d import (
+    Capsule,
+    Circle,
+    Segment,
+    Shape,
+    ShapeDict,
+    Space,
+)
 
 Self = Any
 
@@ -27,6 +34,37 @@ def black() -> Self:
 _BLACK = Color.black()
 
 
+def _mass_and_moment(
+    mass: float = 1.0,
+    moment: float = 1.0,
+    is_static: bool = False,
+) -> tuple[jax.Array, jax.Array]:
+    if is_static:
+        return jnp.array([jnp.inf]), jnp.array([jnp.inf])
+    else:
+        return mass, moment
+
+
+def _circle_mass(radius: float, density: float) -> tuple[jax.Array, jax.Array]:
+    rr = radius**2
+    mass = density * jnp.pi * rr
+    moment = 0.5 * mass * rr
+    return jnp.array([mass]), jax.array([moment])
+
+
+def _capsule_mass(
+    radius: float,
+    length: float,
+    density: float,
+) -> tuple[jax.Array, jax.Array]:
+    rr, ll = radius**2, length**2
+    mass = density * (jnp.pi * radius + 2.0 * length) * radius
+    circle_moment = 0.5 * (rr + ll)
+    box_moment = (4 * rr + ll) / 12
+    moment = mass * (circle_moment + box_moment)
+    return jnp.array([mass]), jax.array([moment])
+
+
 @dataclasses.dataclass
 class SpaceBuilder:
     """
@@ -53,16 +91,19 @@ def add_circle(
         self,
         *,
         radius: float,
-        mass: float,
-        moment: float,
-        elasticity: float,
+        density: float = 1.0,
+        is_static: bool = False,
+        friction: float = 0.8,
+        elasticity: float = 0.8,
         rgba: Color = _BLACK,
     ) -> None:
+        mass, moment = _mass_and_moment(*_circle_mass(radius, density), is_static)
         circle = Circle(
             radius=jnp.array([radius]),
-            mass=jnp.array([mass]),
-            moment=jnp.array([moment]),
+            mass=mass,
+            moment=moment,
             elasticity=jnp.array([elasticity]),
+            friction=jnp.array([friction]),
             rgba=jnp.array(rgba).reshape(1, 4),
         )
         self.circles.append(circle)
@@ -70,19 +111,25 @@ def add_circle(
     def add_capsule(
         self,
         *,
-        length: float,
         radius: float,
-        mass: float,
-        moment: float,
-        elasticity: float,
+        length: float,
+        density: float = 1.0,
+        is_static: bool = False,
+        friction: float = 0.8,
+        elasticity: float = 0.8,
         rgba: Color = _BLACK,
     ) -> None:
+        mass, moment = _mass_and_moment(
+            *_capsule_mass(radius, length, density),
+            is_static,
+        )
         capsule = Capsule(
             length=jnp.array([length]),
             radius=jnp.array([radius]),
-            mass=jnp.array([mass]),
-            moment=jnp.array([moment]),
+            mass=mass,
+            moment=moment,
             elasticity=jnp.array([elasticity]),
+            friction=jnp.array([friction]),
             rgba=jnp.array(rgba).reshape(1, 4),
         )
         self.capsules.append(capsule)
@@ -91,42 +138,36 @@ def add_segment(
         self,
         *,
         length: float,
-        mass: float,
-        moment: float,
-        elasticity: float,
+        friction: float = 0.8,
+        elasticity: float = 0.8,
         rgba: Color = _BLACK,
     ) -> None:
+        mass, moment = _mass_and_moment(is_static=True)
         segment = Segment(
             length=jnp.array([length]),
-            mass=jnp.array([mass]),
-            moment=jnp.array([moment]),
+            mass=mass,
+            moment=moment,
             elasticity=jnp.array([elasticity]),
+            friction=jnp.array([friction]),
             rgba=jnp.array(rgba).reshape(1, 4),
         )
         self.segments.append(segment)
 
     def build(self) -> Space:
-        if len(self.circles) > 0:
-            circle = jax.tree_map(lambda *args: jnp.stack(args), *self.circles)
-        else:
-            circle = None
-        if len(self.capsules) > 0:
-            capsule = jax.tree_map(lambda *args: jnp.stack(args), *self.capsules)
-        else:
-            capsule = None
-        if len(self.segments) > 0:
-            segment = jax.tree_map(lambda *args: jnp.stack(args), *self.segments)
-        else:
-            segment = None
+        def stack_or(sl: list[Shape]) -> Shape | None:
+            if len(sl) > 0:
+                return jax.tree_map(lambda *args: jnp.stack(args), *sl)
+            else:
+                return None
 
         shaped = ShapeDict(
-            circle=circle,
-            segment=segment,
-            capsule=capsule,
+            circle=stack_or(self.circles),
+            segment=stack_or(self.segments),
+            capsule=stack_or(self.capsules),
         )
         dt = self.dt
-        linear_damping = jnp.exp(-dt * self.linear_damping)
-        angular_damping = jnp.exp(-dt * self.angular_damping)
+        linear_damping = jnp.exp(-dt * self.linear_damping).item()
+        angular_damping = jnp.exp(-dt * self.angular_damping).item()
         return Space(
             gravity=jnp.array(self.gravity),
             shaped=shaped,

From db0d6138fe27a648bc5c3603e95d6e5c037325c7 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 29 Sep 2023 18:02:20 +0900
Subject: [PATCH 005/337] Params assertions

---
 src/emevo/environments/phyjax2d_utils.py | 33 ++++++++++++++++++++++--
 1 file changed, 31 insertions(+), 2 deletions(-)

diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index b41552c8..2ed8ff32 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -1,4 +1,5 @@
 import dataclasses
+import warnings
 from typing import Any, NamedTuple
 
 import jax
@@ -49,7 +50,7 @@ def _circle_mass(radius: float, density: float) -> tuple[jax.Array, jax.Array]:
     rr = radius**2
     mass = density * jnp.pi * rr
     moment = 0.5 * mass * rr
-    return jnp.array([mass]), jax.array([moment])
+    return jnp.array([mass]), jnp.array([moment])
 
 
 def _capsule_mass(
@@ -62,7 +63,17 @@ def _capsule_mass(
     circle_moment = 0.5 * (rr + ll)
     box_moment = (4 * rr + ll) / 12
     moment = mass * (circle_moment + box_moment)
-    return jnp.array([mass]), jax.array([moment])
+    return jnp.array([mass]), jnp.array([moment])
+
+
+def _check_params_positive(friction: float, **kwargs) -> None:
+    if friction > 1.0:
+        warnings.warn(
+            f"friction larger than 1 can lead instable simulation (value: {friction})",
+            stacklevel=2,
+        )
+    for key, value in kwargs.items():
+        assert value > 0.0, f"Invalid value for {key}: {value}"
 
 
 @dataclasses.dataclass
@@ -97,6 +108,12 @@ def add_circle(
         elasticity: float = 0.8,
         rgba: Color = _BLACK,
     ) -> None:
+        _check_params_positive(
+            friction=friction,
+            radius=radius,
+            density=density,
+            elasticity=elasticity,
+        )
         mass, moment = _mass_and_moment(*_circle_mass(radius, density), is_static)
         circle = Circle(
             radius=jnp.array([radius]),
@@ -119,6 +136,13 @@ def add_capsule(
         elasticity: float = 0.8,
         rgba: Color = _BLACK,
     ) -> None:
+        _check_params_positive(
+            friction=friction,
+            radius=radius,
+            length=length,
+            density=density,
+            elasticity=elasticity,
+        )
         mass, moment = _mass_and_moment(
             *_capsule_mass(radius, length, density),
             is_static,
@@ -142,6 +166,11 @@ def add_segment(
         elasticity: float = 0.8,
         rgba: Color = _BLACK,
     ) -> None:
+        _check_params_positive(
+            friction=friction,
+            length=length,
+            elasticity=elasticity,
+        )
         mass, moment = _mass_and_moment(is_static=True)
         segment = Segment(
             length=jnp.array([length]),

From 5836885194a1c7239491a88a0437584ce3cdb70c Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 2 Oct 2023 17:54:56 +0900
Subject: [PATCH 006/337] Start implementing Env class

---
 src/emevo/environments/circle_foraging.py | 39 +++++++++++++++++++++++
 src/emevo/environments/phyjax2d_utils.py  |  3 ++
 src/emevo/status.py                       | 36 +++++++++++++++++++--
 src/emevo/types.py                        |  1 -
 4 files changed, 75 insertions(+), 4 deletions(-)
 create mode 100644 src/emevo/environments/circle_foraging.py

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
new file mode 100644
index 00000000..6bcc9fe5
--- /dev/null
+++ b/src/emevo/environments/circle_foraging.py
@@ -0,0 +1,39 @@
+from emevo.env import Env
+from typing import Literal, Callable
+
+
+class CircleForaging(Env):
+
+    def __init__(
+        self,
+        n_initial_bodies: int = 6,
+        food_num_fn: ReprNumFn | str | tuple[str, ...] = "constant",
+        food_loc_fn: ReprLocFn | str | tuple[str, ...] = "gaussian",
+        body_loc_fn: InitLocFn | str | tuple[str, ...] = "uniform",
+        xlim: tuple[float, float] = (0.0, 200.0),
+        ylim: tuple[float, float] = (0.0, 200.0),
+        env_radius: float = 120.0,
+        env_shape: Literal["square", "circle"] = "square",
+        obstacles: list[tuple[float, float, float, float]] | None = None,
+        n_agent_sensors: int = 8,
+        sensor_length: float = 10.0,
+        sensor_range: tuple[float, float] = (-180.0, 180.0),
+        agent_radius: float = 12.0,
+        agent_mass: float = 1.0,
+        agent_friction: float = 0.1,
+        food_radius: float = 4.0,
+        food_mass: float = 0.25,
+        food_friction: float = 0.1,
+        food_initial_force: tuple[float, float] = (0.0, 0.0),
+        foodloc_interval: int = 1000,
+        wall_friction: float = 0.05,
+        max_abs_impulse: float = 0.2,
+        dt: float = 0.05,
+        damping: float = 1.0,
+        encount_threshold: int = 2,
+        n_physics_steps: int = 5,
+        max_place_attempts: int = 10,
+        body_elasticity: float = 0.4,
+        nofriction: bool = False,
+    ) -> None:
+        pass
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 2ed8ff32..186d7b00 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -8,10 +8,13 @@
 from emevo.environments.phyjax2d import (
     Capsule,
     Circle,
+    Contact,
+    Position,
     Segment,
     Shape,
     ShapeDict,
     Space,
+    _capsule_to_circle_impl,
 )
 
 Self = Any
diff --git a/src/emevo/status.py b/src/emevo/status.py
index f10ff4d2..ba580da4 100644
--- a/src/emevo/status.py
+++ b/src/emevo/status.py
@@ -1,18 +1,21 @@
 from __future__ import annotations
 
-import chex
 from typing import Any
 
+import chex
 import jax
-from emevo.types import Self
 import jax.numpy as jnp
 
+Self = Any
+
+
 @chex.dataclass
 class Status:
     """Default status implementation with age and energy."""
 
     age: jax.Array
     energy: jax.Array
+    is_alive: jax.Array
     capacity: float = 100.0
     metadata: dict[str, Any] | None = None
 
@@ -27,5 +30,32 @@ def share(self, ratio: float) -> tuple[Self, jax.Array]:
 
     def update(self, *, energy_delta: jax.Array) -> Self:
         """Update energy."""
-        energy = self.energy + energy_delta
+        energy = self.energy + jnp.where(
+            self.is_alive,
+            energy_delta,
+            jnp.zeros_like(energy_delta),
+        )
         return self.replace(energy=jnp.clip(energy, a_min=0.0, a_max=self.capacity))
+
+
+def init_status(
+    n: int,
+    max_n: int,
+    init_energy: float,
+    capacity: float = 100.0,
+    metadata: dict[str, Any] | None = None,
+) -> Status:
+    assert max_n >= n
+    if max_n == n:
+        is_alive = jnp.ones(n, dtype=bool)
+    else:
+        is_alive = jnp.concatenate(
+            (jnp.ones(n, dtype=bool), jnp.zeros(max_n - n, dtype=bool))
+        )
+    return Status(
+        age=jnp.zeros(max_n, dtype=jnp.int32),
+        energy=jnp.ones(max_n, dtype=jnp.float32),
+        is_alive=is_alive,
+        capacity=capacity,
+        metadata=metadata,
+    )
diff --git a/src/emevo/types.py b/src/emevo/types.py
index f9ec1597..f5aa212a 100644
--- a/src/emevo/types.py
+++ b/src/emevo/types.py
@@ -14,5 +14,4 @@ def dtype(self) -> DType:
 
 DTypeLike = DType | SupportsDType
 PyTree = Any
-Self = Any
 Index = int | jax.Array | Sequence[int]

From 06642e08960471ce0e11304e5d21c886aaf1123f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 3 Oct 2023 18:49:39 +0900
Subject: [PATCH 007/337] Raycast

---
 src/emevo/environments/phyjax2d.py       | 73 ++++++++++++++++++++++++
 src/emevo/environments/phyjax2d_utils.py |  3 -
 2 files changed, 73 insertions(+), 3 deletions(-)

diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 41db1c5a..a8811573 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -965,3 +965,76 @@ def step(space: Space, stated: StateDict, solver: VelocitySolver) -> StateDict:
     )
     statec = update_position(space, state.replace(v=v, p=p))
     return stated.update(statec)
+
+
+@chex.dataclass
+class Raycast:
+    fraction: jax.Array
+    normal: jax.Array
+    hit: jax.Array
+
+
+def circle_raycast(
+    radius: float | jax.Array,
+    max_fraction: float | jax.Array,
+    p1: jax.Array,
+    p2: jax.Array,
+    circle: Circle,
+    p: Position,
+) -> Raycast:
+    s = p1 - p.xy
+    d, length = normalize(p2 - p1)
+    t = -jnp.dot(s, d)
+    c = s + t * d
+    cc = jnp.dot(c, c)
+    rr = (radius + circle.radius) ** 2
+    fraction = t - jnp.sqrt(rr - cc)
+    hitpoint = s + fraction * d
+    normal, _ = normalize(hitpoint)
+    return Raycast(
+        fraction=fraction / length,
+        normal=normal,
+        hit=jnp.logical_and(
+            cc <= rr,
+            jnp.logical_and(
+                fraction >= 0.0,
+                max_fraction * length >= fraction,
+            ),
+        ),
+    )
+
+
+def segment_raycast(
+    max_fraction: float | jax.Array,
+    p1: jax.Array,
+    p2: jax.Array,
+    segment: Segment,
+    p: Position,
+) -> Raycast:
+    d = p2 - p1
+    v1, v2 = _length_to_points(segment.length)
+    v1, v2 = p.transform(v1), p.transform(v2)
+    e = v2 - v1
+    eunit, length = normalize(e)
+    normal = _sv_cross(jnp.ones_like(length) * -1, eunit)
+    numerator = jnp.dot(normal, v1 - p1)
+    denominator = jnp.dot(normal, d)
+    t = numerator / denominator
+    p = p1 + t * d
+    s = jnp.dot(p - v1, eunit)
+    normal = jnp.where(
+        numerator > 0.0,
+        -normal,
+        normal,
+    )
+    return Raycast(
+        fraction=t,
+        normal=normal,
+        hit=jnp.logical_and(
+            denominator != 0.0,
+            jnp.logical_and(
+                jnp.logical_and(t >= 0.0, max_fraction * length >= t),
+                jnp.logical_and(s >= 0.0, length >= s),
+            ),
+        ),
+    )
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 186d7b00..2ed8ff32 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -8,13 +8,10 @@
 from emevo.environments.phyjax2d import (
     Capsule,
     Circle,
-    Contact,
-    Position,
     Segment,
     Shape,
     ShapeDict,
     Space,
-    _capsule_to_circle_impl,
 )
 
 Self = Any

From a5db686f658bdda1d5987a11b16719fc92709120 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 5 Oct 2023 18:00:33 +0900
Subject: [PATCH 008/337] Jaxify locating

---
 src/emevo/environments/phyjax2d.py       |  2 +-
 src/emevo/environments/utils/locating.py | 79 ++++++++++++++----------
 2 files changed, 46 insertions(+), 35 deletions(-)

diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index a8811573..1123a5ae 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -986,7 +986,7 @@ def circle_raycast(
     d, length = normalize(p2 - p1)
     t = -jnp.dot(s, d)
     c = s + t * d
-    cc = jnp.dot(c, c)
+    cc = jnp.linalg.norm(c)
     rr = (radius + circle.radius) ** 2
     fraction = t - jnp.sqrt(rr - cc)
     hitpoint = s + fraction * d
diff --git a/src/emevo/environments/utils/locating.py b/src/emevo/environments/utils/locating.py
index a0329494..b43232cf 100644
--- a/src/emevo/environments/utils/locating.py
+++ b/src/emevo/environments/utils/locating.py
@@ -4,19 +4,20 @@
 import enum
 from typing import Any, Callable, Iterable, Protocol
 
-import numpy as np
-from numpy.random import Generator
-from numpy.typing import ArrayLike, NDArray
+import chex
+import jax
+import jax.numpy as jnp
+from jax.typing import ArrayLike
 
 
 class Coordinate(Protocol):
     def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]:
         ...
 
-    def contains_circle(self, center: ArrayLike, radius: float) -> bool:
+    def contains_circle(self, center: jax.Array, radius: jax.Array) -> bool:
         ...
 
-    def uniform(self, generator: Generator) -> NDArray:
+    def uniform(self, key: chex.PRNGKey) -> jax.Array:
         ...
 
 
@@ -30,18 +31,23 @@ def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]:
         r = self.radius
         return (cx - r, cx + r), (cy - r, cy + r)
 
-    def contains_circle(self, center: ArrayLike, radius: float) -> bool:
-        a2b = np.array(center) - np.array(self.center)  # type: ignore
-        distance = np.linalg.norm(a2b, ord=2) - radius
-        return bool(distance <= self.radius)
-
-    def uniform(self, generator: Generator) -> NDArray:
-        low = [0.0, 0.0]
-        high = [1.0, 2.0 * np.pi]
-        squared_norm, angle = generator.uniform(low=low, high=high)
-        radius = self.radius * np.sqrt(squared_norm)
+    def contains_circle(self, center: jax.Array, radius: jax.Array) -> bool:
+        a2b = center - jnp.array(self.center)
+        distance = jnp.linalg.norm(a2b, ord=2) - radius
+        return distance <= self.radius
+
+    def uniform(self, key: chex.PRNGKey) -> jax.Array:
+        low = jnp.array([0.0, 0.0])
+        high = jnp.array([1.0, 2.0 * jnp.pi])
+        squared_norm, angle = jax.random.uniform(
+            key,
+            shape=(2,),
+            minval=low,
+            maxval=high,
+        )
+        radius = self.radius * jnp.sqrt(squared_norm)
         cx, cy = self.center
-        return np.array([radius * np.cos(angle) + cx, radius * np.sin(angle) + cy])
+        return jnp.array([radius * jnp.cos(angle) + cx, radius * jnp.sin(angle) + cy])
 
 
 @dataclasses.dataclass
@@ -53,24 +59,24 @@ class SquareCoordinate(Coordinate):
     def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]:
         return self.xlim, self.ylim
 
-    def contains_circle(self, center: ArrayLike, radius: float) -> bool:
+    def contains_circle(self, center: jax.Array, radius: float) -> bool:
         xmin, xmax = self.xlim
         ymin, ymax = self.ylim
-        x, y = np.array(center)
+        x, y = center
         offset = self.offset + radius
         x_in = xmin + offset <= x and x <= xmax - offset
         y_in = ymin + offset <= y and y <= ymax - offset
         return x_in and y_in
 
-    def uniform(self, generator: Generator) -> NDArray:
+    def uniform(self, key: chex.PRNGKey) -> jax.Array:
         xmin, xmax = self.xlim
         ymin, ymax = self.ylim
-        low = np.array([xmin + self.offset, ymin + self.offset])
-        high = np.array([xmax - self.offset, ymax - self.offset])
-        return generator.uniform(low=low, high=high)
+        low = jnp.array([xmin + self.offset, ymin + self.offset])
+        high = jnp.array([xmax - self.offset, ymax - self.offset])
+        return jax.random.uniform(key, shape=(2,), minval=low, maxval=high)
 
 
-InitLocFn = Callable[[Generator], NDArray]
+InitLocFn = Callable[[chex.PRNGKey], jax.Array]
 
 
 class InitLoc(str, enum.Enum):
@@ -92,9 +98,10 @@ def __call__(self, *args: Any, **kwargs: Any) -> InitLocFn:
 
 
 def init_loc_gaussian(mean: ArrayLike, stddev: ArrayLike) -> InitLocFn:
-    mean = np.array(mean)
-    stddev = np.array(stddev)
-    return lambda generator: generator.normal(loc=mean, scale=stddev)
+    mean_a = jnp.array(mean)
+    std_a = jnp.array(stddev)
+    shape = mean_a.shape
+    return lambda key: jax.random.normal(key, shape=shape) * std_a + mean_a
 
 
 def init_loc_gaussian_mixture(
@@ -102,20 +109,24 @@ def init_loc_gaussian_mixture(
     mean_arr: ArrayLike,
     stddev_arr: ArrayLike,
 ) -> InitLocFn:
-    mean_a = np.array(mean_arr)
-    stddev_a = np.array(stddev_arr)
+    mean_a = jnp.array(mean_arr)
+    stddev_a = jnp.array(stddev_arr)
+    probs_a = jnp.array(probs)
+    n = probs_a.shape[0]
 
-    def sample(generator: Generator) -> NDArray:
-        i = generator.choice(len(probs), p=probs)
-        return generator.normal(loc=mean_a[i], scale=stddev_a[i])
+    def sample(key: chex.PRNGKey) -> jax.Array:
+        k1, k2 = jax.random.split(key)
+        i = jax.random.choice(k1, n, p=probs)
+        mi, si = mean_a[i], stddev_a[i]
+        return jax.random.normal(k2, shape=mean_a.shape[1:]) * si + mi
 
     return sample
 
 
-def init_loc_pre_defined(locations: Iterable[NDArray]) -> InitLocFn:
+def init_loc_pre_defined(locations: Iterable[jax.Array]) -> InitLocFn:
     location_iter = iter(locations)
-    return lambda _generator: next(location_iter)
+    return lambda _key: next(location_iter)
 
 
 def init_loc_uniform(coordinate: Coordinate) -> InitLocFn:
-    return lambda generator: coordinate.uniform(generator)
+    return lambda key: coordinate.uniform(key)

From 798e3c193298398bd88b4e05de5eb376ea0d11a4 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 6 Oct 2023 18:36:06 +0900
Subject: [PATCH 009/337] Jaxify food repr

---
 src/emevo/environments/utils/color.py     | 12 ---
 src/emevo/environments/utils/food_repr.py | 98 ++++++++++++++---------
 src/emevo/environments/utils/locating.py  | 26 +++---
 3 files changed, 71 insertions(+), 65 deletions(-)
 delete mode 100644 src/emevo/environments/utils/color.py

diff --git a/src/emevo/environments/utils/color.py b/src/emevo/environments/utils/color.py
deleted file mode 100644
index 9187d16f..00000000
--- a/src/emevo/environments/utils/color.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from typing import NamedTuple
-
-
-class Color(NamedTuple):
-    r: int
-    g: int
-    b: int
-    a: int = 255
-
-    @staticmethod
-    def from_float(r: float, g: float, b: float, a: float = 1.0) -> "Color":
-        return Color(int(r * 255), int(g * 255), int(b * 255), int(a * 255))
diff --git a/src/emevo/environments/utils/food_repr.py b/src/emevo/environments/utils/food_repr.py
index c465a687..1d9a0736 100644
--- a/src/emevo/environments/utils/food_repr.py
+++ b/src/emevo/environments/utils/food_repr.py
@@ -5,12 +5,12 @@
 
 import dataclasses
 import enum
-import math
-from typing import Any, Callable, Protocol, Sequence
+from typing import Any, Callable, Protocol
 
-import numpy as np
-from numpy.random import Generator
-from numpy.typing import ArrayLike, NDArray
+import chex
+import jax
+import jax.numpy as jnp
+from numpy.typing import ArrayLike
 
 from emevo.environments.utils.locating import (
     InitLocFn,
@@ -20,13 +20,32 @@
     init_loc_uniform,
 )
 
+Self = Any
 _Location = ArrayLike
 
 
+@chex.dataclass
+class FoodNumState:
+    current: jax.Array
+    internal: jax.Array
+
+    def appears(self) -> jax.Array:
+        return (self.internal - self.current) >= 1.0
+
+    def eaten(self, n: jax.Array) -> Self:
+        return self.replace(current=self.current - n, internal=self.internal - n)
+
+    def fail(self, n: jax.Array) -> Self:
+        return self.replace(internal=self.internal - n)
+
+    def recover(self, n: jax.Array) -> Self:
+        return self.replace(current=self.current + n)
+
+
 class ReprNumFn(Protocol):
     initial: int
 
-    def __call__(self, current_num: int) -> int:
+    def __call__(self, state: FoodNumState) -> FoodNumState:
         ...
 
 
@@ -34,24 +53,21 @@ def __call__(self, current_num: int) -> int:
 class ReprNumConstant:
     initial: int
 
-    def __call__(self, current_num: int) -> int:
-        return max(0, self.initial - current_num)
+    def __call__(self, state: FoodNumState) -> FoodNumState:
+        diff = jnp.clip(self.initial - state.current, a_min=0)
+        state = state.replace(internal=state.internal + diff)
+        return state
 
 
 @dataclasses.dataclass
 class ReprNumLinear:
     initial: int
     dn_dt: float
-    internal: float = dataclasses.field(default=1e9, init=False)
 
-    def __call__(self, current_num: int) -> int:
-        # If some foods are eaten, reflect it to the internal number
-        frac, integ = math.modf(self.internal)
-        if current_num < int(integ):
-            self.internal = float(current_num) + frac
+    def __call__(self, state: FoodNumState) -> FoodNumState:
         # Increase the number of foods by dn_dt
-        self.internal = min(self.internal + self.dn_dt, float(self.initial))
-        return max(0, int(self.internal) - current_num)
+        internal = jnp.clip(state.internal + self.dn_dt, a_max=float(self.initial))
+        return state.replace(internal=internal)
 
 
 @dataclasses.dataclass
@@ -59,16 +75,10 @@ class ReprNumLogistic:
     initial: int
     growth_rate: float
     capacity: float
-    internal: float = dataclasses.field(default=1e9, init=False)
 
-    def __call__(self, current_num: int) -> int:
-        # If some foods are eaten, reflect it to the internal number
-        frac, integ = math.modf(self.internal)
-        if current_num < int(integ):
-            self.internal = float(current_num) + frac
-        dn_dt = self.growth_rate * self.internal * (1 - self.internal / self.capacity)
-        self.internal = self.internal + dn_dt
-        return max(0, int(self.internal) - current_num)
+    def __call__(self, state: FoodNumState) -> FoodNumState:
+        dn_dt = self.growth_rate * state.internal * (1 - state.internal / self.capacity)
+        return state.replace(internal=state.internal + dn_dt)
 
 
 class ReprNum(str, enum.Enum):
@@ -89,11 +99,16 @@ def __call__(self, *args: Any, **kwargs: Any) -> ReprNumFn:
             raise AssertionError("Unreachable")
 
 
-ReprLocFn = Callable[[Generator, Sequence[_Location]], NDArray]
+@chex.dataclass
+class SwitchingState:
+    count: jax.Array
+
+
+ReprLocFn = Callable[[chex.PRNGKey, Any], tuple[jax.Array, Any]]
 
 
 def _wrap_initloc(fn: InitLocFn) -> ReprLocFn:
-    return lambda generator, _locations: fn(generator)
+    return lambda key, _locations: tuple(fn(key), None)
 
 
 class ReprLocSwitching:
@@ -111,14 +126,18 @@ def __init__(
                 locfn_list.append(ReprLoc(name)(*args))
         self._locfn_list = locfn_list
         self._interval = interval
-        self._count = 0
-        self._current = 0
+        self._n = len(locfn_list)
 
-    def __call__(self, generator: Generator, loc: Sequence[_Location]) -> NDArray:
-        self._count += 1
-        if self._count % self._interval == 0:
-            self._current = (self._current + 1) % len(self._locfn_list)
-        return self._locfn_list[self._current](generator, loc)
+    def __call__(self, key: chex.PRNGKey, state: SwitchingState) -> jax.Array:
+        count = state.count + 1
+        index = (count // self._interval) % self._n
+        result, _ = jax.lax.switch(
+            index,
+            self._locfn_list,
+            key,
+            None,  # Assume that each fn takes no state
+        )
+        return result, state.replace(count=self.count, current=self.current)
 
 
 class ReprLoc(str, enum.Enum):
@@ -130,15 +149,16 @@ class ReprLoc(str, enum.Enum):
     SWITCHING = "switching"
     UNIFORM = "uniform"
 
-    def __call__(self, *args: Any, **kwargs: Any) -> ReprLocFn:
+    def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprLocFn, Any]:
         if self is ReprLoc.GAUSSIAN:
-            return _wrap_initloc(init_loc_gaussian(*args, **kwargs))
+            return _wrap_initloc(init_loc_gaussian(*args, **kwargs)), None
         elif self is ReprLoc.GAUSSIAN_MIXTURE:
-            return _wrap_initloc(init_loc_gaussian_mixture(*args, **kwargs))
+            return _wrap_initloc(init_loc_gaussian_mixture(*args, **kwargs)), None
         elif self is ReprLoc.PRE_DIFINED:
-            return _wrap_initloc(init_loc_pre_defined(*args, **kwargs))
+            return _wrap_initloc(init_loc_pre_defined(*args, **kwargs)), None
         elif self is ReprLoc.SWITCHING:
-            return ReprLocSwitching(*args, **kwargs)
+            state = SwitchingState(jnp.zeros(1), jnp.zeros(1))
+            return ReprLocSwitching(*args, **kwargs), state
         elif self is ReprLoc.UNIFORM:
             return _wrap_initloc(init_loc_uniform(*args, **kwargs))
         else:
diff --git a/src/emevo/environments/utils/locating.py b/src/emevo/environments/utils/locating.py
index b43232cf..9e754d19 100644
--- a/src/emevo/environments/utils/locating.py
+++ b/src/emevo/environments/utils/locating.py
@@ -2,7 +2,8 @@
 
 import dataclasses
 import enum
-from typing import Any, Callable, Iterable, Protocol
+from collections.abc import Iterable
+from typing import Any, Callable, Protocol
 
 import chex
 import jax
@@ -14,7 +15,7 @@ class Coordinate(Protocol):
     def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]:
         ...
 
-    def contains_circle(self, center: jax.Array, radius: jax.Array) -> bool:
+    def contains_circle(self, center: jax.Array, radius: jax.Array) -> jax.Array:
         ...
 
     def uniform(self, key: chex.PRNGKey) -> jax.Array:
@@ -31,10 +32,10 @@ def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]:
         r = self.radius
         return (cx - r, cx + r), (cy - r, cy + r)
 
-    def contains_circle(self, center: jax.Array, radius: jax.Array) -> bool:
+    def contains_circle(self, center: jax.Array, radius: jax.Array) -> jax.Array:
         a2b = center - jnp.array(self.center)
-        distance = jnp.linalg.norm(a2b, ord=2) - radius
-        return distance <= self.radius
+        distance = jnp.linalg.norm(a2b, ord=2)
+        return distance + radius <= self.radius
 
     def uniform(self, key: chex.PRNGKey) -> jax.Array:
         low = jnp.array([0.0, 0.0])
@@ -54,25 +55,22 @@ def uniform(self, key: chex.PRNGKey) -> jax.Array:
 class SquareCoordinate(Coordinate):
     xlim: tuple[float, float]
     ylim: tuple[float, float]
-    offset: float
 
     def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]:
         return self.xlim, self.ylim
 
-    def contains_circle(self, center: jax.Array, radius: float) -> bool:
+    def contains_circle(self, center: jax.Array, radius: jax.Array) -> bool:
         xmin, xmax = self.xlim
         ymin, ymax = self.ylim
-        x, y = center
-        offset = self.offset + radius
-        x_in = xmin + offset <= x and x <= xmax - offset
-        y_in = ymin + offset <= y and y <= ymax - offset
-        return x_in and y_in
+        low = jnp.array([xmin, ymin]) + radius
+        high = jnp.array([xmax, ymax]) - radius
+        return jnp.logical_and(low <= center, center <= high)
 
     def uniform(self, key: chex.PRNGKey) -> jax.Array:
         xmin, xmax = self.xlim
         ymin, ymax = self.ylim
-        low = jnp.array([xmin + self.offset, ymin + self.offset])
-        high = jnp.array([xmax - self.offset, ymax - self.offset])
+        low = jnp.array([xmin, ymin])
+        high = jnp.array([xmax, ymax])
         return jax.random.uniform(key, shape=(2,), minval=low, maxval=high)
 
 

From 0fa95671301e9aa74e99ab219de8b3f7c672cf2b Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 10 Oct 2023 12:46:03 +0900
Subject: [PATCH 010/337] Minor fixes

---
 src/emevo/environments/utils/food_repr.py | 6 ++----
 src/emevo/environments/utils/locating.py  | 5 ++++-
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/emevo/environments/utils/food_repr.py b/src/emevo/environments/utils/food_repr.py
index 1d9a0736..5111e754 100644
--- a/src/emevo/environments/utils/food_repr.py
+++ b/src/emevo/environments/utils/food_repr.py
@@ -5,12 +5,11 @@
 
 import dataclasses
 import enum
-from typing import Any, Callable, Protocol
+from typing import Any, Callable, Iterable, Protocol
 
 import chex
 import jax
 import jax.numpy as jnp
-from numpy.typing import ArrayLike
 
 from emevo.environments.utils.locating import (
     InitLocFn,
@@ -21,7 +20,6 @@
 )
 
 Self = Any
-_Location = ArrayLike
 
 
 @chex.dataclass
@@ -115,7 +113,7 @@ class ReprLocSwitching:
     def __init__(
         self,
         interval: int,
-        *reprloc_fns: tuple[tuple[str, ...] | ReprLocFn],
+        *reprloc_fns: Iterable[tuple[str, ...] | ReprLocFn],
     ) -> None:
         locfn_list = []
         for fn_or_base in reprloc_fns:
diff --git a/src/emevo/environments/utils/locating.py b/src/emevo/environments/utils/locating.py
index 9e754d19..87e93905 100644
--- a/src/emevo/environments/utils/locating.py
+++ b/src/emevo/environments/utils/locating.py
@@ -81,6 +81,7 @@ class InitLoc(str, enum.Enum):
     """Methods to determine the location of new foods or agents"""
 
     GAUSSIAN = "gaussian"
+    GAUSSIAN_MIXTURE = "gaussian_mixture"
     PRE_DIFINED = "pre-defined"
     UNIFORM = "uniform"
 
@@ -91,6 +92,8 @@ def __call__(self, *args: Any, **kwargs: Any) -> InitLocFn:
             return init_loc_pre_defined(*args, **kwargs)
         elif self is InitLoc.UNIFORM:
             return init_loc_uniform(*args, **kwargs)
+        elif self is InitLoc.GAUSSIAN_MIXTURE:
+            return init_loc_gaussian_mixture(*args, **kwargs)
         else:
             raise AssertionError("Unreachable")
 
@@ -114,7 +117,7 @@ def init_loc_gaussian_mixture(
 
     def sample(key: chex.PRNGKey) -> jax.Array:
         k1, k2 = jax.random.split(key)
-        i = jax.random.choice(k1, n, p=probs)
+        i = jax.random.choice(k1, n, p=probs_a)
         mi, si = mean_a[i], stddev_a[i]
         return jax.random.normal(k2, shape=mean_a.shape[1:]) * si + mi
 

From 1c44fa9fe70fb74ea0c821cdab9e200797a47d62 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 10 Oct 2023 16:31:40 +0900
Subject: [PATCH 011/337] Bug fixes in init and food loc

---
 src/emevo/environments/utils/food_repr.py | 27 ++++++++++------------
 src/emevo/environments/utils/locating.py  | 28 ++++++++++++++---------
 2 files changed, 29 insertions(+), 26 deletions(-)

diff --git a/src/emevo/environments/utils/food_repr.py b/src/emevo/environments/utils/food_repr.py
index 5111e754..d68410a5 100644
--- a/src/emevo/environments/utils/food_repr.py
+++ b/src/emevo/environments/utils/food_repr.py
@@ -5,13 +5,15 @@
 
 import dataclasses
 import enum
-from typing import Any, Callable, Iterable, Protocol
+from collections.abc import Iterable
+from typing import Any, Callable, Protocol
 
 import chex
 import jax
 import jax.numpy as jnp
 
 from emevo.environments.utils.locating import (
+    InitLoc,
     InitLocFn,
     init_loc_gaussian,
     init_loc_gaussian_mixture,
@@ -99,29 +101,29 @@ def __call__(self, *args: Any, **kwargs: Any) -> ReprNumFn:
 
 @chex.dataclass
 class SwitchingState:
-    count: jax.Array
+    count: int
 
 
 ReprLocFn = Callable[[chex.PRNGKey, Any], tuple[jax.Array, Any]]
 
 
 def _wrap_initloc(fn: InitLocFn) -> ReprLocFn:
-    return lambda key, _locations: tuple(fn(key), None)
+    return lambda key, _state: (fn(key), _state)
 
 
 class ReprLocSwitching:
     def __init__(
         self,
         interval: int,
-        *reprloc_fns: Iterable[tuple[str, ...] | ReprLocFn],
+        *initloc_fns: Iterable[tuple[str, ...] | InitLocFn],
     ) -> None:
         locfn_list = []
-        for fn_or_base in reprloc_fns:
+        for fn_or_base in initloc_fns:
             if callable(fn_or_base):
                 locfn_list.append(fn_or_base)
             else:
                 name, *args = fn_or_base
-                locfn_list.append(ReprLoc(name)(*args))
+                locfn_list.append(InitLoc(name)(*args))
         self._locfn_list = locfn_list
         self._interval = interval
         self._n = len(locfn_list)
@@ -129,13 +131,8 @@ def __init__(
     def __call__(self, key: chex.PRNGKey, state: SwitchingState) -> jax.Array:
         count = state.count + 1
         index = (count // self._interval) % self._n
-        result, _ = jax.lax.switch(
-            index,
-            self._locfn_list,
-            key,
-            None,  # Assume that each fn takes no state
-        )
-        return result, state.replace(count=self.count, current=self.current)
+        result = jax.lax.switch(index, self._locfn_list, key)
+        return result, state.replace(count=count)
 
 
 class ReprLoc(str, enum.Enum):
@@ -155,9 +152,9 @@ def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprLocFn, Any]:
         elif self is ReprLoc.PRE_DIFINED:
             return _wrap_initloc(init_loc_pre_defined(*args, **kwargs)), None
         elif self is ReprLoc.SWITCHING:
-            state = SwitchingState(jnp.zeros(1), jnp.zeros(1))
+            state = SwitchingState(count=0)
             return ReprLocSwitching(*args, **kwargs), state
         elif self is ReprLoc.UNIFORM:
-            return _wrap_initloc(init_loc_uniform(*args, **kwargs))
+            return _wrap_initloc(init_loc_uniform(*args, **kwargs)), None
         else:
             raise AssertionError("Unreachable")
diff --git a/src/emevo/environments/utils/locating.py b/src/emevo/environments/utils/locating.py
index 87e93905..1afe9c06 100644
--- a/src/emevo/environments/utils/locating.py
+++ b/src/emevo/environments/utils/locating.py
@@ -80,20 +80,20 @@ def uniform(self, key: chex.PRNGKey) -> jax.Array:
 class InitLoc(str, enum.Enum):
     """Methods to determine the location of new foods or agents"""
 
+    CHOICE = "choice"
     GAUSSIAN = "gaussian"
-    GAUSSIAN_MIXTURE = "gaussian_mixture"
-    PRE_DIFINED = "pre-defined"
+    GAUSSIAN_MIXTURE = "gaussian-mixture"
     UNIFORM = "uniform"
 
     def __call__(self, *args: Any, **kwargs: Any) -> InitLocFn:
-        if self is InitLoc.GAUSSIAN:
+        if self is InitLoc.CHOICE:
+            return init_loc_choice(*args, **kwargs)
+        elif self is InitLoc.GAUSSIAN:
             return init_loc_gaussian(*args, **kwargs)
-        elif self is InitLoc.PRE_DIFINED:
-            return init_loc_pre_defined(*args, **kwargs)
-        elif self is InitLoc.UNIFORM:
-            return init_loc_uniform(*args, **kwargs)
         elif self is InitLoc.GAUSSIAN_MIXTURE:
             return init_loc_gaussian_mixture(*args, **kwargs)
+        elif self is InitLoc.UNIFORM:
+            return init_loc_uniform(*args, **kwargs)
         else:
             raise AssertionError("Unreachable")
 
@@ -119,14 +119,20 @@ def sample(key: chex.PRNGKey) -> jax.Array:
         k1, k2 = jax.random.split(key)
         i = jax.random.choice(k1, n, p=probs_a)
         mi, si = mean_a[i], stddev_a[i]
-        return jax.random.normal(k2, shape=mean_a.shape[1:]) * si + mi
+        return jax.random.norm al(k2, shape=mean_a.shape[1:]) * si + mi
 
     return sample
 
 
-def init_loc_pre_defined(locations: Iterable[jax.Array]) -> InitLocFn:
-    location_iter = iter(locations)
-    return lambda _key: next(location_iter)
+def init_loc_choice(locations: Iterable[jax.Array]) -> InitLocFn:
+    loc_a = jnp.array(list(locations))
+    n = loc_a.shape[0]
+
+    def sample(key: chex.PRNGKey) -> jax.Array:
+        i = jax.random.choice(key, n)
+        return loc_a[i]
+
+    return sample
 
 
 def init_loc_uniform(coordinate: Coordinate) -> InitLocFn:

From 05e68f04000bcd4121c6cff1aab7d7782a3ae42a Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 10 Oct 2023 17:43:00 +0900
Subject: [PATCH 012/337] Fix ReprNum

---
 src/emevo/environments/circle_foraging.py |  8 ++++++++
 src/emevo/environments/utils/food_repr.py | 24 +++++++++++++++--------
 2 files changed, 24 insertions(+), 8 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 6bcc9fe5..ad0e5203 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -1,5 +1,13 @@
 from emevo.env import Env
 from typing import Literal, Callable
+from emevo.environments.utils.food_repr import ReprLoc, ReprLocFn, ReprNum, ReprNumFn
+from emevo.environments.utils.locating import (
+    CircleCoordinate,
+    Coordinate,
+    InitLoc,
+    InitLocFn,
+    SquareCoordinate,
+)
 
 
 class CircleForaging(Env):
diff --git a/src/emevo/environments/utils/food_repr.py b/src/emevo/environments/utils/food_repr.py
index d68410a5..0006ecaf 100644
--- a/src/emevo/environments/utils/food_repr.py
+++ b/src/emevo/environments/utils/food_repr.py
@@ -26,8 +26,8 @@
 
 @chex.dataclass
 class FoodNumState:
-    current: jax.Array
-    internal: jax.Array
+    current: int
+    internal: float
 
     def appears(self) -> jax.Array:
         return (self.internal - self.current) >= 1.0
@@ -59,7 +59,7 @@ def __call__(self, state: FoodNumState) -> FoodNumState:
         return state
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(frozen=True)
 class ReprNumLinear:
     initial: int
     dn_dt: float
@@ -70,7 +70,7 @@ def __call__(self, state: FoodNumState) -> FoodNumState:
         return state.replace(internal=internal)
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(frozen=True)
 class ReprNumLogistic:
     initial: int
     growth_rate: float
@@ -88,15 +88,23 @@ class ReprNum(str, enum.Enum):
     LINEAR = "linear"
     LOGISTIC = "logistic"
 
-    def __call__(self, *args: Any, **kwargs: Any) -> ReprNumFn:
+    def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn,]:
+        if len(args) > 0:
+            initial = args[0]
+        elif "initial" in kwargs:
+            initial = kwargs["initial"]
+        else:
+            raise ValueError("'initial' is required for all ReprNum functions")
+        state = FoodNumState(int(initial), float(initial))
         if self is ReprNum.CONSTANT:
-            return ReprNumConstant(*args, **kwargs)
+            fn = ReprNumConstant(**kwargs)
         elif self is ReprNum.LINEAR:
-            return ReprNumLinear(*args, **kwargs)
+            fn = ReprNumLinear(**kwargs)
         elif self is ReprNum.LOGISTIC:
-            return ReprNumLogistic(*args, **kwargs)
+            fn = ReprNumLogistic(**kwargs)
         else:
             raise AssertionError("Unreachable")
+        return fn, state
 
 
 @chex.dataclass

From 611842cc83cbfd002476e98b7d701a2e65cf9218 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 11 Oct 2023 13:46:25 +0900
Subject: [PATCH 013/337] Default arguments to fail/recover

---
 src/emevo/environments/utils/food_repr.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/emevo/environments/utils/food_repr.py b/src/emevo/environments/utils/food_repr.py
index 0006ecaf..e86d1993 100644
--- a/src/emevo/environments/utils/food_repr.py
+++ b/src/emevo/environments/utils/food_repr.py
@@ -35,10 +35,10 @@ def appears(self) -> jax.Array:
     def eaten(self, n: jax.Array) -> Self:
         return self.replace(current=self.current - n, internal=self.internal - n)
 
-    def fail(self, n: jax.Array) -> Self:
+    def fail(self, n: int = 1) -> Self:
         return self.replace(internal=self.internal - n)
 
-    def recover(self, n: jax.Array) -> Self:
+    def recover(self, n: int = 1) -> Self:
         return self.replace(current=self.current + n)
 
 

From 5d05df6adc49a93715ef3ebd6b9f3f4311c51cf2 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 11 Oct 2023 17:26:24 +0900
Subject: [PATCH 014/337] Utils to make outer wall

---
 src/emevo/__init__.py                        |  1 +
 src/emevo/environments/circle_foraging.py    | 83 ++++++++++++++++++--
 src/emevo/environments/phyjax2d_utils.py     | 49 +++++++++++-
 src/emevo/environments/pymunk_envs/circle.py |  1 -
 src/emevo/environments/utils/locating.py     |  2 +-
 5 files changed, 125 insertions(+), 11 deletions(-)

diff --git a/src/emevo/__init__.py b/src/emevo/__init__.py
index 0b11d603..9767be61 100644
--- a/src/emevo/__init__.py
+++ b/src/emevo/__init__.py
@@ -7,6 +7,7 @@
 from emevo.env import Profile, Env
 from emevo.environments import make, register
 from emevo.status import Status
+from emevo.vec2d import Vec2d
 
 
 def __disable_loguru() -> None:
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index ad0e5203..81913f8e 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -1,5 +1,16 @@
+from typing import Callable, Literal, NamedTuple
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+
 from emevo.env import Env
-from typing import Literal, Callable
+from emevo.environments.phyjax2d import Space
+from emevo.environments.phyjax2d_utils import (
+    SpaceBuilder,
+    make_approx_circle,
+    make_square,
+)
 from emevo.environments.utils.food_repr import ReprLoc, ReprLocFn, ReprNum, ReprNumFn
 from emevo.environments.utils.locating import (
     CircleCoordinate,
@@ -10,8 +21,61 @@
 )
 
 
-class CircleForaging(Env):
+class CFObs(NamedTuple):
+    """Observation of an agent."""
+
+    sensor: jax.Array
+    collision: jax.Array
+    velocity: jax.Array
+    angle: float
+    angular_velocity: float
+    energy: float
 
+    def __array__(self) -> jax.Array:
+        return jnp.concatenate(
+            (
+                self.sensor.ravel(),
+                self.collision,
+                self.velocity,
+                [self.angle, self.angular_velocity, self.energy],
+            )
+        )
+
+
+def _make_space(
+    dt: float,
+    coordinate: CircleCoordinate | SquareCoordinate,
+    linear_damping: float = 0.9,
+    angular_damping: float = 0.9,
+    n_velocity_iter: int = 6,
+    n_position_iter: int = 2,
+    food_radius: float = 4.0,
+) -> Space:
+    builder = SpaceBuilder(
+        gravity=(0.0, 0.0),  # No gravity
+        dt=dt,
+        linear_damping=linear_damping,
+        angular_damping=angular_damping,
+        n_velocity_iter=n_velocity_iter,
+        n_position_iter=n_position_iter,
+    )
+    if isinstance(coordinate, CircleCoordinate):
+        outer_walls = make_approx_circle(coordinate.center, coordinate.radius)
+    else:
+        outer_walls = make_square(
+            *coordinate.xlim,
+            *coordinate.ylim,
+            rounded_offset=np.floor(food_radius * 2 / (np.sqrt(2) - 1.0)),
+        )
+    for wall in outer_walls:
+        a2b = wall[1] - wall[0]
+        angle = a2b.angle
+        builder.add_segment(
+            length=a2b.length,
+        )
+
+
+class CircleForaging(Env):
     def __init__(
         self,
         n_initial_bodies: int = 6,
@@ -30,18 +94,21 @@ def __init__(
         agent_mass: float = 1.0,
         agent_friction: float = 0.1,
         food_radius: float = 4.0,
-        food_mass: float = 0.25,
-        food_friction: float = 0.1,
-        food_initial_force: tuple[float, float] = (0.0, 0.0),
+        food_mass: float = 0.1,
+        food_friction: float = 0.0,
         foodloc_interval: int = 1000,
-        wall_friction: float = 0.05,
         max_abs_impulse: float = 0.2,
+        wall_friction: float = 0.1,
         dt: float = 0.05,
         damping: float = 1.0,
-        encount_threshold: int = 2,
         n_physics_steps: int = 5,
         max_place_attempts: int = 10,
         body_elasticity: float = 0.4,
         nofriction: bool = False,
     ) -> None:
-        pass
+        if env_shape == "square":
+            self._coordinate = SquareCoordinate(xlim, ylim)
+        elif env_shape == "circle":
+            self._coordinate = CircleCoordinate((env_radius, env_radius), env_radius)
+        else:
+            raise ValueError(f"Unsupported env_shape {env_shape}")
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 2ed8ff32..2465b3cd 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -4,7 +4,9 @@
 
 import jax
 import jax.numpy as jnp
+import numpy as np
 
+from emevo import Vec2d, Vec2dLike
 from emevo.environments.phyjax2d import (
     Capsule,
     Circle,
@@ -83,7 +85,7 @@ class SpaceBuilder:
     Not expected to used with `jax.jit`.
     """
 
-    gravity: tuple[float, float] = dataclasses.field(default=(0.0, -9.8))
+    gravity: Vec2dLike = dataclasses.field(default=(0.0, -9.8))
     circles: list[Circle] = dataclasses.field(default_factory=list)
     capsules: list[Capsule] = dataclasses.field(default_factory=list)
     segments: list[Segment] = dataclasses.field(default_factory=list)
@@ -210,3 +212,48 @@ def stack_or(sl: list[Shape]) -> Shape | None:
             allowed_penetration=self.allowed_penetration,
             bounce_threshold=self.bounce_threshold,
         )
+
+
+def make_approx_circle(
+    center: Vec2dLike,
+    radius: float,
+    n_lines: int = 32,
+) -> list[tuple[Vec2d, Vec2d]]:
+    unit = np.pi * 2 / n_lines
+    lines = []
+    t0 = Vec2d(radius, 0.0)
+    for i in range(n_lines):
+        start = center + t0.rotated(unit * i)
+        end = center + t0.rotated(unit * (i + 1))
+        lines.append((start, end))
+    return lines
+
+
+def make_square(
+    xmin: float,
+    xmax: float,
+    ymin: float,
+    ymax: float,
+    rounded_offset: float | None = None,
+) -> list[tuple[Vec2d, Vec2d]]:
+    p1 = Vec2d(xmin, ymin)
+    p2 = Vec2d(xmin, ymax)
+    p3 = Vec2d(xmax, ymax)
+    p4 = Vec2d(xmax, ymin)
+    lines = []
+    if rounded_offset is not None:
+        for start, end in [(p1, p2), (p2, p3), (p3, p4), (p4, p1)]:
+            s2end = Vec2d(*end) - Vec2d(*start)
+            offset = s2end.normalized() * rounded_offset
+            stop = end - offset
+            lines.append((start + offset, stop))
+            stop2end = end - stop
+            center = stop + stop2end.rotated(-np.pi / 2)
+            for i in range(4):
+                start = center + stop2end.rotated(np.pi / 8 * i)
+                end = center + stop2end.rotated(np.pi / 8 * (i + 1))
+                lines.append((start, end))
+    else:
+        for start, end in [(p1, p2), (p2, p3), (p3, p4), (p4, p1)]:
+            lines.append((start, end))
+    return lines
diff --git a/src/emevo/environments/pymunk_envs/circle.py b/src/emevo/environments/pymunk_envs/circle.py
index 47f71459..3fe9ba56 100644
--- a/src/emevo/environments/pymunk_envs/circle.py
+++ b/src/emevo/environments/pymunk_envs/circle.py
@@ -26,7 +26,6 @@
 
 FN = TypeVar("FN")
 
-
 class CFObs(NamedTuple):
     """Observation of an agent."""
 
diff --git a/src/emevo/environments/utils/locating.py b/src/emevo/environments/utils/locating.py
index 1afe9c06..73c266ed 100644
--- a/src/emevo/environments/utils/locating.py
+++ b/src/emevo/environments/utils/locating.py
@@ -119,7 +119,7 @@ def sample(key: chex.PRNGKey) -> jax.Array:
         k1, k2 = jax.random.split(key)
         i = jax.random.choice(k1, n, p=probs_a)
         mi, si = mean_a[i], stddev_a[i]
-        return jax.random.norm al(k2, shape=mean_a.shape[1:]) * si + mi
+        return jax.random.normal(k2, shape=mean_a.shape[1:]) * si + mi
 
     return sample
 

From d98ad01b86ec57f96acbf23a1c77b574f41c5ef3 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 12 Oct 2023 14:18:00 +0900
Subject: [PATCH 015/337] make_space

---
 src/emevo/environments/circle_foraging.py | 28 +++++++++++++++++------
 src/emevo/environments/phyjax2d.py        |  7 +++++-
 2 files changed, 27 insertions(+), 8 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 81913f8e..9749971b 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -5,7 +5,7 @@
 import numpy as np
 
 from emevo.env import Env
-from emevo.environments.phyjax2d import Space
+from emevo.environments.phyjax2d import Space, Position, State
 from emevo.environments.phyjax2d_utils import (
     SpaceBuilder,
     make_approx_circle,
@@ -49,8 +49,11 @@ def _make_space(
     angular_damping: float = 0.9,
     n_velocity_iter: int = 6,
     n_position_iter: int = 2,
+    n_max_agents: int = 40,
+    n_max_foods: int = 20,
+    agent_radius: float = 10.0,
     food_radius: float = 4.0,
-) -> Space:
+) -> tuple[Space, State]:
     builder = SpaceBuilder(
         gravity=(0.0, 0.0),  # No gravity
         dt=dt,
@@ -59,6 +62,7 @@ def _make_space(
         n_velocity_iter=n_velocity_iter,
         n_position_iter=n_position_iter,
     )
+    # Set walls
     if isinstance(coordinate, CircleCoordinate):
         outer_walls = make_approx_circle(coordinate.center, coordinate.radius)
     else:
@@ -67,12 +71,23 @@ def _make_space(
             *coordinate.ylim,
             rounded_offset=np.floor(food_radius * 2 / (np.sqrt(2) - 1.0)),
         )
+    segments = []
     for wall in outer_walls:
         a2b = wall[1] - wall[0]
-        angle = a2b.angle
-        builder.add_segment(
-            length=a2b.length,
-        )
+        angle = jnp.array(a2b.angle)
+        xy = jnp.array(wall[0] + wall[1]) / 2
+        position = Position(angle=angle, xy=xy)
+        segments.append(position)
+        builder.add_segment(length=a2b.length, friction=0.1, elasticity=0.2)
+    seg_position = jax.tree_map(lambda *args: jnp.stack(args), *segments)
+    seg_state = State.from_position(seg_position)
+    for _ in range(n_max_agents):
+        # Use the default density for now
+        builder.add_circle(radius=agent_radius, friction=0.1, elasticity=0.2)
+    for _ in range(n_max_foods):
+        builder.add_circle(radius=food_radius, friction=0.0, elasticity=0.0)
+    space = builder.build()
+    return space, seg_state
 
 
 class CircleForaging(Env):
@@ -98,7 +113,6 @@ def __init__(
         food_friction: float = 0.0,
         foodloc_interval: int = 1000,
         max_abs_impulse: float = 0.2,
-        wall_friction: float = 0.1,
         dt: float = 0.05,
         damping: float = 1.0,
         n_physics_steps: int = 5,
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 1123a5ae..d56869a3 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -225,13 +225,18 @@ class State(PyTreeOps):
     f: Force
     is_active: jax.Array
 
+    @staticmethod
+    def from_position(p: Position) -> Self:
+        n = p.batch_size()
+        return State(p=p, v=Velocity.zeros(n), f=Force.zeros(n), is_active=jnp.ones(n))
+
     @staticmethod
     def zeros(n: int) -> Self:
         return State(
             p=Position.zeros(n),
             v=Velocity.zeros(n),
             f=Force.zeros(n),
-            is_active=jnp.zeros(n),
+            is_active=jnp.ones(n),
         )
 
 

From c377cb48a2d412442f1d6cc52a7cae8732f4b802 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 12 Oct 2023 17:52:23 +0900
Subject: [PATCH 016/337] Implement circle_overwrap

---
 README.md                                 |  9 ++---
 src/emevo/environments/circle_foraging.py | 12 +++---
 src/emevo/environments/phyjax2d.py        | 22 +++++------
 src/emevo/environments/phyjax2d_utils.py  | 47 ++++++++++++++++++++++-
 src/emevo/environments/utils/food_repr.py | 21 ++++++----
 5 files changed, 79 insertions(+), 32 deletions(-)

diff --git a/README.md b/README.md
index 6901816a..de89cd23 100644
--- a/README.md
+++ b/README.md
@@ -33,8 +33,7 @@ nox -s smoke --no-install -- smoke-tests/circle_asexual_repr.py \
 nox -s tests
 ```
 
-## (WIP) Design
-- Gym-like environment API (`emevo.Env`)
-- `emevo.Body` as a key to physical existence of agents
-- Energy/Age status of agents (`emevo.Status`)
-- Birth/Hazard functions (`emevo.birth_and_death`)
+# License
+Apache 2.0
+
+`vec2d.py` is copied from [PyMunk](pymunk.org) with the license-header as-is.
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 9749971b..9166025b 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -5,7 +5,7 @@
 import numpy as np
 
 from emevo.env import Env
-from emevo.environments.phyjax2d import Space, Position, State
+from emevo.environments.phyjax2d import Position, Space, State, StateDict
 from emevo.environments.phyjax2d_utils import (
     SpaceBuilder,
     make_approx_circle,
@@ -27,9 +27,9 @@ class CFObs(NamedTuple):
     sensor: jax.Array
     collision: jax.Array
     velocity: jax.Array
-    angle: float
-    angular_velocity: float
-    energy: float
+    angle: jax.Array
+    angular_velocity: jax.Array
+    energy: jax.Array
 
     def __array__(self) -> jax.Array:
         return jnp.concatenate(
@@ -37,7 +37,9 @@ def __array__(self) -> jax.Array:
                 self.sensor.ravel(),
                 self.collision,
                 self.velocity,
-                [self.angle, self.angular_velocity, self.energy],
+                self.angle,
+                self.angular_velocity,
+                self.energy,
             )
         )
 
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index d56869a3..505604a3 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -442,7 +442,7 @@ class StateDict:
     segment: State | None = None
     capsule: State | None = None
 
-    def concat(self) -> None:
+    def concat(self) -> Self:
         states = [s for s in self.values() if s is not None]
         return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *states)
 
@@ -689,7 +689,7 @@ def init_contact_helper(
     # Compute elasiticity * relative_vel
     dv = _dv2from1(v1, r1, v2, r2)
     vn = _vmap_dot(dv, contact.normal)
-    return ContactHelper(
+    return ContactHelper(  # type: ignore
         tangent=tangent,
         mass_normal=1 / (kn1 + kn2),
         mass_tangent=1 / (kt1 + kt2),
@@ -985,9 +985,9 @@ def circle_raycast(
     p1: jax.Array,
     p2: jax.Array,
     circle: Circle,
-    p: Position,
+    state: State,
 ) -> Raycast:
-    s = p1 - p.xy
+    s = p1 - state.p.xy
     d, length = normalize(p2 - p1)
     t = -jnp.dot(s, d)
     c = s + t * d
@@ -996,7 +996,7 @@ def circle_raycast(
     fraction = t - jnp.sqrt(rr - cc)
     hitpoint = s + fraction * d
     normal, _ = normalize(hitpoint)
-    return Raycast(
+    return Raycast(  # type: ignore
         fraction=fraction / length,
         normal=normal,
         hit=jnp.logical_and(
@@ -1014,11 +1014,11 @@ def segment_raycast(
     p1: jax.Array,
     p2: jax.Array,
     segment: Segment,
-    p: Position,
+    state: State,
 ) -> Raycast:
     d = p2 - p1
     v1, v2 = _length_to_points(segment.length)
-    v1, v2 = p.transform(v1), p.transform(v2)
+    v1, v2 = state.p.transform(v1), state.p.transform(v2)
     e = v2 - v1
     eunit, length = normalize(e)
     normal = _sv_cross(jnp.ones_like(length) * -1, eunit)
@@ -1027,12 +1027,8 @@ def segment_raycast(
     t = numerator / denominator
     p = p1 + t * d
     s = jnp.dot(p - v1, eunit)
-    normal = jnp.where(
-        numerator > 0.0,
-        -normal,
-        normal,
-    )
-    return Raycast(
+    normal = jnp.where(numerator > 0.0, -normal, normal)
+    return Raycast(  # type: ignore
         fraction=t,
         normal=normal,
         hit=jnp.logical_and(
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 2465b3cd..5c83ce67 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -6,7 +6,6 @@
 import jax.numpy as jnp
 import numpy as np
 
-from emevo import Vec2d, Vec2dLike
 from emevo.environments.phyjax2d import (
     Capsule,
     Circle,
@@ -14,7 +13,12 @@
     Shape,
     ShapeDict,
     Space,
+    StateDict,
+    _length_to_points,
+    _vmap_dot,
+    normalize,
 )
+from emevo.vec2d import Vec2d, Vec2dLike
 
 Self = Any
 
@@ -45,7 +49,7 @@ def _mass_and_moment(
     if is_static:
         return jnp.array([jnp.inf]), jnp.array([jnp.inf])
     else:
-        return mass, moment
+        return jnp.array(mass), jnp.array(moment)
 
 
 def _circle_mass(radius: float, density: float) -> tuple[jax.Array, jax.Array]:
@@ -257,3 +261,42 @@ def make_square(
         for start, end in [(p1, p2), (p2, p3), (p3, p4), (p4, p1)]:
             lines.append((start, end))
     return lines
+
+
+def circle_overwrap(
+    shaped: ShapeDict,
+    stated: StateDict,
+    xy: jax.Array,
+    radius: jax.Array,
+) -> jax.Array:
+    # Circle-circle overwrap
+
+    if stated.circle is not None and shaped.circle is not None:
+        cpos = stated.circle.p.xy
+        # Suppose that cpos.shape == (N, 2) and xy.shape == (2,)
+        _, dist = jax.vmap(normalize)(cpos - jnp.expand_dims(xy, axis=0))
+        penetration = shaped.circle.radius + radius - dist
+        circle_overwrap = jnp.any(penetration >= 0)
+    else:
+        circle_overwrap = jnp.array(False)
+
+    # Circle-segment overwrap
+
+    if stated.segment is not None and shaped.segment is not None:
+        spos = stated.segment.p
+        # Suppose that cpos.shape == (N, 2) and xy.shape == (2,)
+        pb = spos.inv_transform(jnp.expand_dims(xy, axis=0))
+        p1, p2 = _length_to_points(shaped.segment.length)
+        edge = p2 - p1
+        s1 = jnp.expand_dims(_vmap_dot(pb - p1, edge), axis=1)
+        s2 = jnp.expand_dims(_vmap_dot(p2 - pb, edge), axis=1)
+        in_segment = jnp.logical_and(s1 >= 0.0, s2 >= 0.0)
+        ee = jnp.sum(jnp.square(edge), axis=-1, keepdims=True)
+        pa = jnp.where(in_segment, p1 + edge * s1 / ee, jnp.where(s1 < 0.0, p1, p2))
+        _, dist = jax.vmap(normalize)(pb - pa)
+        penetration = radius - dist
+        segment_overwrap = jnp.any(penetration >= 0)
+    else:
+        segment_overwrap = jnp.array(False)
+
+    return jnp.logical_or(circle_overwrap, segment_overwrap)
diff --git a/src/emevo/environments/utils/food_repr.py b/src/emevo/environments/utils/food_repr.py
index e86d1993..158d8e01 100644
--- a/src/emevo/environments/utils/food_repr.py
+++ b/src/emevo/environments/utils/food_repr.py
@@ -26,8 +26,8 @@
 
 @chex.dataclass
 class FoodNumState:
-    current: int
-    internal: float
+    current: jax.Array
+    internal: jax.Array
 
     def appears(self) -> jax.Array:
         return (self.internal - self.current) >= 1.0
@@ -88,14 +88,17 @@ class ReprNum(str, enum.Enum):
     LINEAR = "linear"
     LOGISTIC = "logistic"
 
-    def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn,]:
+    def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn, FoodNumState]:
         if len(args) > 0:
             initial = args[0]
         elif "initial" in kwargs:
             initial = kwargs["initial"]
         else:
             raise ValueError("'initial' is required for all ReprNum functions")
-        state = FoodNumState(int(initial), float(initial))
+        state = FoodNumState(  # type: ignore
+            current=jnp.array(int(initial)),
+            internal=jnp.array(float(initial)),
+        )
         if self is ReprNum.CONSTANT:
             fn = ReprNumConstant(**kwargs)
         elif self is ReprNum.LINEAR:
@@ -109,7 +112,7 @@ def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn,]:
 
 @chex.dataclass
 class SwitchingState:
-    count: int
+    count: jax.Array
 
 
 ReprLocFn = Callable[[chex.PRNGKey, Any], tuple[jax.Array, Any]]
@@ -136,7 +139,11 @@ def __init__(
         self._interval = interval
         self._n = len(locfn_list)
 
-    def __call__(self, key: chex.PRNGKey, state: SwitchingState) -> jax.Array:
+    def __call__(
+        self,
+        key: chex.PRNGKey,
+        state: SwitchingState,
+    ) -> tuple[jax.Array, SwitchingState]:
         count = state.count + 1
         index = (count // self._interval) % self._n
         result = jax.lax.switch(index, self._locfn_list, key)
@@ -160,7 +167,7 @@ def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprLocFn, Any]:
         elif self is ReprLoc.PRE_DIFINED:
             return _wrap_initloc(init_loc_pre_defined(*args, **kwargs)), None
         elif self is ReprLoc.SWITCHING:
-            state = SwitchingState(count=0)
+            state = SwitchingState(count=jnp.array(0))  # type: ignore
             return ReprLocSwitching(*args, **kwargs), state
         elif self is ReprLoc.UNIFORM:
             return _wrap_initloc(init_loc_uniform(*args, **kwargs)), None

From b46dc856edadccfe71fa0f4a56ecc3ce996a0318 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 12 Oct 2023 17:54:52 +0900
Subject: [PATCH 017/337] Vec2d

---
 src/emevo/vec2d.py | 417 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 417 insertions(+)
 create mode 100644 src/emevo/vec2d.py

diff --git a/src/emevo/vec2d.py b/src/emevo/vec2d.py
new file mode 100644
index 00000000..801e0d76
--- /dev/null
+++ b/src/emevo/vec2d.py
@@ -0,0 +1,417 @@
+# ----------------------------------------------------------------------------
+# pymunk
+# Copyright (c) 2007-2020 Victor Blomqvist
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+# ----------------------------------------------------------------------------
+
+"""This module contain the Vec2d class that is used in all of pymunk when a
+vector is needed.
+
+The Vec2d class is used almost everywhere in pymunk for 2d coordinates and
+vectors, for example to define gravity vector in a space. However, pymunk is
+smart enough to convert tuples or tuple like objects to Vec2ds so you usually
+do not need to explicitly do conversions if you happen to have a tuple::
+
+    >>> import pymunk
+    >>> space = pymunk.Space()
+    >>> space.gravity
+    Vec2d(0.0, 0.0)
+    >>> space.gravity = 3,5
+    >>> space.gravity
+    Vec2d(3.0, 5.0)
+    >>> space.gravity += 2,6
+    >>> space.gravity
+    Vec2d(5.0, 11.0)
+
+More examples::
+
+    >>> from pymunk.vec2d import Vec2d
+    >>> Vec2d(7.3, 4.2)
+    Vec2d(7.3, 4.2)
+    >>> Vec2d(7.3, 4.2) + Vec2d(1, 2)
+    Vec2d(8.3, 6.2)
+
+"""
+from __future__ import annotations
+
+__docformat__ = "reStructuredText"
+
+import math
+import numbers
+import operator
+from typing import Any, NamedTuple
+
+__all__ = ["Vec2d", "Vec2dLike"]
+
+Self = Any
+
+
+class Vec2d(NamedTuple):
+    """2d vector class, supports vector and scalar operators, and also
+    provides some high level functions.
+    """
+
+    x: float
+    y: float
+
+    # String representaion (for debugging)
+    def __repr__(self) -> str:
+        return f"Vec2d({self.x}, {self.y}"
+
+    # Addition
+    def __add__(self, other: tuple[float, float]) -> Self:  # type: ignore
+        """Add a Vec2d with another Vec2d or tuple of size 2
+
+        >>> Vec2d(3,4) + Vec2d(1,2)
+        Vec2d(4, 6)
+        >>> Vec2d(3,4) + (1,2)
+        Vec2d(4, 6)
+        """
+        assert (
+            len(other) == 2
+        ), f"{other} not supported. Only Vec2d and Sequence of length 2 is supported."
+
+        return Vec2d(self.x + other[0], self.y + other[1])
+
+    def __radd__(self, other: tuple[float, float]) -> Self:
+        """Add a tuple of size 2 with a Vec2d
+
+        >>> (1,2) + Vec2d(3,4)
+        Vec2d(4, 6)
+        """
+        return self.__add__(other)
+
+    # Subtraction
+    def __sub__(self, other: tuple[float, float]) -> Self:
+        """Subtract a Vec2d with another Vec2d or tuple of size 2
+
+        >>> Vec2d(3,4) - Vec2d(1,2)
+        Vec2d(2, 2)
+        >>> Vec2d(3,4) - (1,2)
+        Vec2d(2, 2)
+        """
+        return Vec2d(self.x - other[0], self.y - other[1])
+
+    def __rsub__(self, other: tuple[float, float]) -> Self:
+        """Subtract a tuple of size 2 with a Vec2d
+
+        >>> (1,2) - Vec2d(3,4)
+        Vec2d(-2, -2)
+        """
+        assert (
+            len(other) == 2
+        ), f"{other} not supported. Only Vec2d and Sequence of length 2 is supported."
+        return Vec2d(other[0] - self.x, other[1] - self.y)
+
+    # Multiplication
+    def __mul__(self, other: float) -> Self:  # type: ignore[override]
+        """Multiply with a float
+
+        >>> Vec2d(3,6) * 2.5
+        Vec2d(7.5, 15.0)
+        """
+        assert isinstance(other, numbers.Real)
+        return Vec2d(self.x * other, self.y * other)
+
+    def __rmul__(self, other: float) -> Self:  # type: ignore[override]
+        """Multiply a float with a Vec2d
+
+        >>> 2.5 * Vec2d(3,6)
+        Vec2d(7.5, 15.0)
+        """
+        return self.__mul__(other)
+
+    # Division
+    def __floordiv__(self, other: float) -> Self:
+        """Floor division by a float (also known as integer division)
+
+        >>> Vec2d(3,6) // 2.0
+        Vec2d(1.0, 3.0)
+        """
+        assert isinstance(other, numbers.Real)
+        return Vec2d(self.x // other, self.y // other)
+
+    def __truediv__(self, other: float) -> Self:
+        """Division by a float
+
+        >>> Vec2d(3,6) / 2.0
+        Vec2d(1.5, 3.0)
+        """
+        assert isinstance(other, numbers.Real)
+        return Vec2d(self.x / other, self.y / other)
+
+    # Unary operations
+    def __neg__(self) -> Self:
+        """Return the negated version of the Vec2d
+
+        >>> -Vec2d(1,-2)
+        Vec2d(-1, 2)
+        """
+        return Vec2d(operator.neg(self.x), operator.neg(self.y))
+
+    def __pos__(self) -> Self:
+        """Return the unary pos of the Vec2d.
+
+        >>> +Vec2d(1,-2)
+        Vec2d(1, -2)
+        """
+        return Vec2d(operator.pos(self.x), operator.pos(self.y))
+
+    def __abs__(self) -> float:
+        """Return the length of the Vec2d
+
+        >>> abs(Vec2d(3,4))
+        5.0
+        """
+        return self.length
+
+    # vectory functions
+    def get_length_sqrd(self) -> float:
+        """Get the squared length of the vector.
+        If the squared length is enough it is more efficient to use this method
+        instead of first calling get_length() or access .length and then do a
+        x**2.
+
+        >>> v = Vec2d(3,4)
+        >>> v.get_length_sqrd() == v.length**2
+        True
+
+        :return: The squared length
+        """
+        return self.x**2 + self.y**2
+
+    @property
+    def length(self) -> float:
+        """Get the length of the vector.
+
+        >>> Vec2d(10, 0).length
+        10.0
+        >>> '%.2f' % Vec2d(10, 20).length
+        '22.36'
+
+        :return: The length
+        """
+        return math.sqrt(self.x**2 + self.y**2)
+
+    def scale_to_length(self, length: float) -> Self:
+        """Return a copy of this vector scaled to the given length.
+
+        >>> '%.2f, %.2f' % Vec2d(10, 20).scale_to_length(20)
+        '8.94, 17.89'
+        """
+        old_length = self.length
+        return Vec2d(self.x * length / old_length, self.y * length / old_length)
+
+    def rotated(self, angle_radians: float) -> Self:
+        """Create and return a new vector by rotating this vector by
+        angle_radians radians.
+
+        :return: Rotated vector
+        """
+        cos = math.cos(angle_radians)
+        sin = math.sin(angle_radians)
+        x = self.x * cos - self.y * sin
+        y = self.x * sin + self.y * cos
+        return Vec2d(x, y)
+
+    def rotated_degrees(self, angle_degrees: float) -> Self:
+        """Create and return a new vector by rotating this vector by
+        angle_degrees degrees.
+
+        :return: Rotade vector
+        """
+        return self.rotated(math.radians(angle_degrees))
+
+    @property
+    def angle(self) -> float:
+        """The angle (in radians) of the vector"""
+        if self.get_length_sqrd() == 0:
+            return 0
+        return math.atan2(self.y, self.x)
+
+    @property
+    def angle_degrees(self) -> float:
+        """Gets the angle (in degrees) of a vector"""
+        return math.degrees(self.angle)
+
+    def get_angle_between(self, other: tuple[float, float]) -> float:
+        """Get the angle between the vector and the other in radians
+
+        :return: The angle
+        """
+        assert len(other) == 2
+        cross = self.x * other[1] - self.y * other[0]
+        dot = self.x * other[0] + self.y * other[1]
+        return math.atan2(cross, dot)
+
+    def get_angle_degrees_between(self, other: Self) -> float:
+        """Get the angle between the vector and the other in degrees
+
+        :return: The angle (in degrees)
+        """
+        return math.degrees(self.get_angle_between(other))
+
+    def normalized(self) -> Self:
+        """Get a normalized copy of the vector
+        Note: This function will return 0 if the length of the vector is 0.
+
+        :return: A normalized vector
+        """
+        length = self.length
+        if length != 0:
+            return self / length
+        return Vec2d(0, 0)
+
+    def normalized_and_length(self) -> tuple[Self, float]:
+        """Normalize the vector and return its length before the normalization
+
+        :return: The length before the normalization
+        """
+        length = self.length
+        if length != 0:
+            return self / length, length
+        return Vec2d(0, 0), 0
+
+    def perpendicular(self) -> Self:
+        return Vec2d(-self.y, self.x)
+
+    def perpendicular_normal(self) -> Self:
+        length = self.length
+        if length != 0:
+            return Vec2d(-self.y / length, self.x / length)
+        return Vec2d(self.x, self.y)
+
+    def dot(self, other: tuple[float, float]) -> float:
+        """The dot product between the vector and other vector
+            v1.dot(v2) -> v1.x*v2.x + v1.y*v2.y
+
+        :return: The dot product
+        """
+        assert len(other) == 2
+        return float(self.x * other[0] + self.y * other[1])
+
+    def get_distance(self, other: tuple[float, float]) -> float:
+        """The distance between the vector and other vector
+
+        :return: The distance
+        """
+        assert len(other) == 2
+        return math.sqrt((self.x - other[0]) ** 2 + (self.y - other[1]) ** 2)
+
+    def get_dist_sqrd(self, other: tuple[float, float]) -> float:
+        """The squared distance between the vector and other vector
+        It is more efficent to use this method than to call get_distance()
+        first and then do a sqrt() on the result.
+
+        :return: The squared distance
+        """
+        assert len(other) == 2
+        return (self.x - other[0]) ** 2 + (self.y - other[1]) ** 2
+
+    def projection(self, other: tuple[float, float]) -> Self:
+        """Project this vector on top of other vector"""
+        assert len(other) == 2
+        other_length_sqrd = other[0] * other[0] + other[1] * other[1]
+        if other_length_sqrd == 0.0:
+            return Vec2d(0, 0)
+        projected_length_times_other_length = self.dot(other)
+        new_length = projected_length_times_other_length / other_length_sqrd
+        return Vec2d(other[0] * new_length, other[1] * new_length)
+
+    def cross(self, other: tuple[float, float]) -> float:
+        """The cross product between the vector and other vector
+            v1.cross(v2) -> v1.x*v2.y - v1.y*v2.x
+
+        :return: The cross product
+        """
+        assert len(other) == 2
+        return self.x * other[1] - self.y * other[0]
+
+    def interpolate_to(self, other: tuple[float, float], range: float) -> Self:
+        assert len(other) == 2
+        return Vec2d(
+            self.x + (other[0] - self.x) * range, self.y + (other[1] - self.y) * range
+        )
+
+    def convert_to_basis(
+        self,
+        x_vector: tuple[float, float],
+        y_vector: tuple[float, float],
+    ) -> Self:
+        assert len(x_vector) == 2
+        assert len(y_vector) == 2
+        x = self.dot(x_vector) / Vec2d(*x_vector).get_length_sqrd()
+        y = self.dot(y_vector) / Vec2d(*y_vector).get_length_sqrd()
+        return Vec2d(x, y)
+
+    @property
+    def int_tuple(self) -> tuple[int, int]:
+        """The x and y values of this vector as a tuple of ints.
+        Uses round() to round to closest int.
+
+        >>> Vec2d(0.9, 2.4).int_tuple
+        (1, 2)
+        """
+        return round(self.x), round(self.y)
+
+    @staticmethod
+    def zero() -> Self:
+        """A vector of zero length.
+
+        >>> Vec2d.zero()
+        Vec2d(0, 0)
+        """
+        return Vec2d(0, 0)
+
+    @staticmethod
+    def unit() -> Self:
+        """A unit vector pointing up
+
+        >>> Vec2d.unit()
+        Vec2d(0, 1)
+        """
+        return Vec2d(0, 1)
+
+    @staticmethod
+    def ones() -> Self:
+        """A vector where both x and y is 1
+
+        >>> Vec2d.ones()
+        Vec2d(1, 1)
+        """
+        return Vec2d(1, 1)
+
+    # Extra functions, mainly for chipmunk
+    def cpvrotate(self, other: tuple[float, float]) -> Self:
+        """Uses complex multiplication to rotate this vector by the other."""
+        assert len(other) == 2
+        return Vec2d(
+            self.x * other[0] - self.y * other[1], self.x * other[1] + self.y * other[0]
+        )
+
+    def cpvunrotate(self, other: tuple[float, float]) -> Self:
+        """The inverse of cpvrotate"""
+        assert len(other) == 2
+        return Vec2d(
+            self.x * other[0] + self.y * other[1], self.y * other[0] - self.x * other[1]
+        )
+
+
+Vec2dLike = Vec2d | tuple[float, float]

From 0a8fce2431495d5c3172e6d2a3d628ed06cbf61f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 13 Oct 2023 15:50:46 +0900
Subject: [PATCH 018/337] Placement

---
 src/emevo/environments/placement.py | 38 +++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 src/emevo/environments/placement.py

diff --git a/src/emevo/environments/placement.py b/src/emevo/environments/placement.py
new file mode 100644
index 00000000..cfaf9d92
--- /dev/null
+++ b/src/emevo/environments/placement.py
@@ -0,0 +1,38 @@
+from typing import Any
+
+import chex
+import jax
+import jax.numpy as jnp
+
+from emevo.environments.phyjax2d import ShapeDict, StateDict
+from emevo.environments.phyjax2d_utils import circle_overwrap
+from emevo.environments.utils.food_repr import ReprLocFn
+from emevo.environments.utils.locating import Coordinate, InitLocFn
+
+
+def _fail(*args, **kargs) -> jax.Array:
+    return jnp.array([jnp.inf, jnp.inf])
+
+
+def place_food(
+    n_trial: int,
+    food_radius: float,
+    coordinate: Coordinate,
+    reprloc_fn: ReprLocFn,
+    reprloc_state: Any,
+    key: chex.PRNGKey,
+    shaped: ShapeDict,
+    stated: StateDict,
+) -> None:
+    keys = jax.random.split(key, n_trial)
+    loc_fn = jax.vmap(reprloc_fn, in_axes=(0, None), out_axes=(0, None))
+    locations, state = loc_fn(keys, reprloc_state)
+    radius = jnp.ones(n_trial) * food_radius
+    ok = jnp.logical_and(
+        jax.vmap(coordinate.contains_circle)(locations, radius),
+        circle_overwrap(shaped, stated, locations, radius),
+    )
+    return jax.lax.cond(
+        ok.any(),
+        _fail,
+    )

From bfe88fa35d4a0f2c367d3797dfe9639f13c97de3 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 13 Oct 2023 18:23:06 +0900
Subject: [PATCH 019/337] Implement placement functions

---
 src/emevo/environments/placement.py       | 63 +++++++++++++++++------
 src/emevo/environments/utils/food_repr.py | 27 +++++-----
 2 files changed, 63 insertions(+), 27 deletions(-)

diff --git a/src/emevo/environments/placement.py b/src/emevo/environments/placement.py
index cfaf9d92..29475fd3 100644
--- a/src/emevo/environments/placement.py
+++ b/src/emevo/environments/placement.py
@@ -1,17 +1,30 @@
-from typing import Any
-
 import chex
 import jax
 import jax.numpy as jnp
 
 from emevo.environments.phyjax2d import ShapeDict, StateDict
 from emevo.environments.phyjax2d_utils import circle_overwrap
-from emevo.environments.utils.food_repr import ReprLocFn
+from emevo.environments.utils.food_repr import ReprLocFn, ReprLocState
 from emevo.environments.utils.locating import Coordinate, InitLocFn
 
 
-def _fail(*args, **kargs) -> jax.Array:
-    return jnp.array([jnp.inf, jnp.inf])
+def _place_common(
+    coordinate: Coordinate,
+    shaped: ShapeDict,
+    stated: StateDict,
+    locations: jax.Array,
+    radius: jax.Array,
+) -> jax.Array:
+    ok = jnp.logical_and(
+        jax.vmap(coordinate.contains_circle)(locations, radius),
+        circle_overwrap(shaped, stated, locations, radius),
+    )
+
+    def step_fun(state: jax.Array, xi: tuple[jax.Array, jax.Array]):
+        is_ok, loc = xi
+        return jax.lax.select(is_ok, loc, state), None
+
+    return jax.lax.scan(step_fun, jnp.array([jnp.inf, jnp.inf]), (ok, locations))[0]
 
 
 def place_food(
@@ -19,20 +32,40 @@ def place_food(
     food_radius: float,
     coordinate: Coordinate,
     reprloc_fn: ReprLocFn,
-    reprloc_state: Any,
+    reprloc_state: ReprLocState,
     key: chex.PRNGKey,
     shaped: ShapeDict,
     stated: StateDict,
-) -> None:
+) -> jax.Array:
+    """Returns `[inf, inf]` if it fails"""
     keys = jax.random.split(key, n_trial)
     loc_fn = jax.vmap(reprloc_fn, in_axes=(0, None), out_axes=(0, None))
-    locations, state = loc_fn(keys, reprloc_state)
-    radius = jnp.ones(n_trial) * food_radius
-    ok = jnp.logical_and(
-        jax.vmap(coordinate.contains_circle)(locations, radius),
-        circle_overwrap(shaped, stated, locations, radius),
+    locations = loc_fn(keys, reprloc_state)
+    return _place_common(
+        shaped,
+        stated,
+        coordinate,
+        locations,
+        jnp.ones(n_trial) * food_radius,
     )
-    return jax.lax.cond(
-        ok.any(),
-        _fail,
+
+
+def place_agent(
+    n_trial: int,
+    agent_radius: float,
+    coordinate: Coordinate,
+    initloc_fn: InitLocFn,
+    key: chex.PRNGKey,
+    shaped: ShapeDict,
+    stated: StateDict,
+) -> jax.Array:
+    """Returns `[inf, inf]` if it fails"""
+    keys = jax.random.split(key, n_trial)
+    locations = jax.vmap(initloc_fn)(keys)
+    return _place_common(
+        shaped,
+        stated,
+        coordinate,
+        locations,
+        jnp.ones(n_trial) * agent_radius,
     )
diff --git a/src/emevo/environments/utils/food_repr.py b/src/emevo/environments/utils/food_repr.py
index 158d8e01..9dba022f 100644
--- a/src/emevo/environments/utils/food_repr.py
+++ b/src/emevo/environments/utils/food_repr.py
@@ -111,15 +111,18 @@ def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn, FoodNumState]:
 
 
 @chex.dataclass
-class SwitchingState:
-    count: jax.Array
+class ReprLocState:
+    n_produced: jax.Array
 
+    def step(self) -> Self:
+        return self.replace(n_produced=self.n_produced + 1)
 
-ReprLocFn = Callable[[chex.PRNGKey, Any], tuple[jax.Array, Any]]
 
+ReprLocFn = Callable[[chex.PRNGKey, ReprLocState], jax.Array]
 
-def _wrap_initloc(fn: InitLocFn) -> ReprLocFn:
-    return lambda key, _state: (fn(key), _state)
+
+def _wrap_initloc(fn: InitLocFn) -> ReprLocState:
+    return lambda key, state: (fn(key), state)
 
 
 class ReprLocSwitching:
@@ -142,8 +145,8 @@ def __init__(
     def __call__(
         self,
         key: chex.PRNGKey,
-        state: SwitchingState,
-    ) -> tuple[jax.Array, SwitchingState]:
+        state: ReprLocState,
+    ) -> tuple[jax.Array, ReprLocState]:
         count = state.count + 1
         index = (count // self._interval) % self._n
         result = jax.lax.switch(index, self._locfn_list, key)
@@ -160,16 +163,16 @@ class ReprLoc(str, enum.Enum):
     UNIFORM = "uniform"
 
     def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprLocFn, Any]:
+        state = ReprLocState(n_produced=jnp.array(0))
         if self is ReprLoc.GAUSSIAN:
-            return _wrap_initloc(init_loc_gaussian(*args, **kwargs)), None
+            return _wrap_initloc(init_loc_gaussian(*args, **kwargs)), state
         elif self is ReprLoc.GAUSSIAN_MIXTURE:
-            return _wrap_initloc(init_loc_gaussian_mixture(*args, **kwargs)), None
+            return _wrap_initloc(init_loc_gaussian_mixture(*args, **kwargs)), state
         elif self is ReprLoc.PRE_DIFINED:
-            return _wrap_initloc(init_loc_pre_defined(*args, **kwargs)), None
+            return _wrap_initloc(init_loc_pre_defined(*args, **kwargs)), state
         elif self is ReprLoc.SWITCHING:
-            state = SwitchingState(count=jnp.array(0))  # type: ignore
             return ReprLocSwitching(*args, **kwargs), state
         elif self is ReprLoc.UNIFORM:
-            return _wrap_initloc(init_loc_uniform(*args, **kwargs)), None
+            return _wrap_initloc(init_loc_uniform(*args, **kwargs)), state
         else:
             raise AssertionError("Unreachable")

From 68a096b0c2b422b8d1920efd3639239feacdc941 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 16 Oct 2023 16:15:43 +0900
Subject: [PATCH 020/337] Temporally remove outdated tests and make existing
 ones work

---
 src/emevo/environments/__init__.py            |  14 +-
 src/emevo/environments/placement.py           |   2 +
 .../pymunk_envs => }/moderngl_vis.py          |   0
 .../pymunk_envs => }/qt_widget.py             |   0
 src/emevo/spaces.py                           |  19 +-
 src/emevo/status.py                           |   1 +
 tests/test_circle.py                          | 287 ------------------
 tests/test_manager.py                         | 160 ----------
 tests/test_spaces.py                          |  59 ++--
 tests/test_status.py                          |  24 +-
 tests/test_survival_prob.py                   |  31 --
 11 files changed, 62 insertions(+), 535 deletions(-)
 rename src/emevo/{environments/pymunk_envs => }/moderngl_vis.py (100%)
 rename src/emevo/{environments/pymunk_envs => }/qt_widget.py (100%)
 delete mode 100644 tests/test_circle.py
 delete mode 100644 tests/test_manager.py
 delete mode 100644 tests/test_survival_prob.py

diff --git a/src/emevo/environments/__init__.py b/src/emevo/environments/__init__.py
index 7914ed7c..87a23755 100644
--- a/src/emevo/environments/__init__.py
+++ b/src/emevo/environments/__init__.py
@@ -2,12 +2,12 @@
 """
 
 
-from emevo.environments.pymunk_envs import circle
-from emevo.environments.pymunk_envs.circle import CFBody, CFObs, CircleForaging
+# from emevo.environments.pymunk_envs import circle
+# from emevo.environments.pymunk_envs.circle import CFBody, CFObs, CircleForaging
 from emevo.environments.registry import description, make, register
 
-register(
-    "CircleForaging-v0",
-    circle.CircleForaging,
-    "Pymunk circle foraging environment",
-)
+# register(
+#     "CircleForaging-v0",
+#     circle.CircleForaging,
+#     "Pymunk circle foraging environment",
+# )
diff --git a/src/emevo/environments/placement.py b/src/emevo/environments/placement.py
index 29475fd3..e7ffd122 100644
--- a/src/emevo/environments/placement.py
+++ b/src/emevo/environments/placement.py
@@ -1,3 +1,5 @@
+"""Place agent and food"""
+
 import chex
 import jax
 import jax.numpy as jnp
diff --git a/src/emevo/environments/pymunk_envs/moderngl_vis.py b/src/emevo/moderngl_vis.py
similarity index 100%
rename from src/emevo/environments/pymunk_envs/moderngl_vis.py
rename to src/emevo/moderngl_vis.py
diff --git a/src/emevo/environments/pymunk_envs/qt_widget.py b/src/emevo/qt_widget.py
similarity index 100%
rename from src/emevo/environments/pymunk_envs/qt_widget.py
rename to src/emevo/qt_widget.py
diff --git a/src/emevo/spaces.py b/src/emevo/spaces.py
index 4bdd7ccd..0b8b6411 100644
--- a/src/emevo/spaces.py
+++ b/src/emevo/spaces.py
@@ -103,12 +103,9 @@ def clip(self, x: jax.Array) -> jax.Array:
         return jnp.clip(x, a_min=self.low, a_max=self.high)
 
     def contains(self, x: jax.Array) -> bool:
-        return bool(
-            jnp.can_cast(x.dtype, self.dtype)
-            and x.shape == self.shape
-            and jnp.all(x >= self.low).item()
-            and jnp.all(x <= self.high).item()
-        )
+        type_ok = jnp.can_cast(x.dtype, self.dtype) and x.shape == self.shape
+        value_ok = jnp.logical_and(jnp.all(x >= self.low), jnp.all(x <= self.high))
+        return type_ok and value_ok.item()
 
     def flatten(self) -> BoxSpace:
         return BoxSpace(low=self.low.flatten(), high=self.high.flatten())
@@ -196,11 +193,10 @@ def _broadcast(
         value = jnp.full(shape, value, dtype=dtype)
     else:
         assert isinstance(value, jax.Array)
-        if jnp.any(jnp.isinf(value)):
+        isinf = jnp.isinf(value)
+        if jnp.any(isinf):
             # create new array with dtype, but maintain old one to preserve jnp.inf
-            temp = value.astype(dtype)
-            temp[jnp.isinf(value)] = get_inf(dtype, inf_sign)
-            value = temp
+            value = jnp.where(isinf, get_inf(dtype, inf_sign), value.astype(dtype))
     return value
 
 
@@ -234,7 +230,8 @@ def flatten(self) -> BoxSpace:
         return BoxSpace(low=jnp.zeros(self.n), high=jnp.ones(self.n))
 
     def sample(self, key: chex.PRNGKey) -> int:
-        return jax.random.randint(key, shape=(self.n,)) + self.start
+        rn = jax.random.randint(key, shape=self.shape, minval=0, maxval=self.n)
+        return rn.item() + self.start
 
     def __repr__(self) -> str:
         """Gives a string representation of this space."""
diff --git a/src/emevo/status.py b/src/emevo/status.py
index ba580da4..d1e2459f 100644
--- a/src/emevo/status.py
+++ b/src/emevo/status.py
@@ -39,6 +39,7 @@ def update(self, *, energy_delta: jax.Array) -> Self:
 
 
 def init_status(
+    *,
     n: int,
     max_n: int,
     init_energy: float,
diff --git a/tests/test_circle.py b/tests/test_circle.py
deleted file mode 100644
index 00528b48..00000000
--- a/tests/test_circle.py
+++ /dev/null
@@ -1,287 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-
-import numpy as np
-import pytest
-from loguru import logger
-from numpy.testing import assert_almost_equal
-from numpy.typing import NDArray
-from pymunk.vec2d import Vec2d
-
-from emevo import _test_utils as utils
-from emevo.environments import CircleForaging
-
-
-def almost_equal(actual: NDArray, desired: float) -> NDArray:
-    diff = np.abs(actual - desired)
-    return diff < 1e-6
-
-
-def assert_either_a_or_b(
-    actual: NDArray,
-    desired_a: float,
-    desired_b: float,
-    require_both: bool = True,
-) -> None:
-    almost_equal_to_a = almost_equal(actual, desired_a)
-    almost_equal_to_b = almost_equal(actual, desired_b)
-    almost_equal_to_a_or_b = np.logical_or(almost_equal_to_a, almost_equal_to_b)
-    if not np.all(almost_equal_to_a_or_b):
-        raise AssertionError(
-            f"Some elements of {actual} are not equal to"
-            + f" either of {desired_a} or {desired_b}"
-        )
-    if require_both:
-        if not np.any(almost_equal_to_a):
-            raise AssertionError(
-                f"At least one element of {actual} should be {desired_a}"
-            )
-        if not np.any(almost_equal_to_b):
-            raise AssertionError(
-                f"At least one element of {actual} should be {desired_b}"
-            )
-
-
-logger.enable("emevo")
-
-# Not to depend on the default argument
-AGENT_RADIUS: float = 8.0
-DT: float = 0.05
-FOOD_RADIUS: float = 4.0
-N_SENSORS: int = 4
-SENSOR_LENGTH: float = 10.0
-YLIM: tuple[float, float] = 0.0, 200
-
-
-@pytest.fixture
-def env() -> CircleForaging:
-    return utils.predefined_env(
-        agent_radius=AGENT_RADIUS,
-        sensor_length=SENSOR_LENGTH,
-        n_agent_sensors=N_SENSORS,
-        n_physics_steps=1,
-        energy_fn=lambda body: float(body.index),
-        ylim=YLIM,
-        dt=DT,
-    )
-
-
-@dataclasses.dataclass
-class DebugLogHandler:
-    logs: list[str] = dataclasses.field(default_factory=list)
-
-    def __post_init__(self) -> None:
-        logger.add(self, format="{message}", level="DEBUG")
-
-    def __call__(self, message: str) -> None:
-        self.logs.append(message)
-
-    def __contains__(self, query: str) -> bool:
-        for log in self.logs:
-            if query in log:
-                return True
-        return False
-
-    def once(self, query: str) -> bool:
-        n_occurance = 0
-        for log in self.logs:
-            if query in log:
-                n_occurance += 1
-        return n_occurance == 1
-
-
-def test_birth(env: CircleForaging) -> None:
-    """
-    Test that
-    1. we can't place body if it overlaps another object
-    2. we can place body otherwise.
-    """
-    assert len(env.bodies()) == 3
-    body = next(filter(lambda body: body.info().position.x > 100.0, env.bodies()))
-    place = body.info().position
-    assert env.locate_body(place, 1) is None
-    assert env.locate_body(place + Vec2d(6.5, -5.0), 1) is None
-    assert env.locate_body(place + Vec2d(-16.0, 0.0), 1) is not None
-    env.remove_body(body)
-    assert env.locate_body(place, 1) is not None
-
-
-def test_death(env: CircleForaging) -> None:
-    """
-    A  F
-
-    A  A
-    Kill the lower right body.
-    """
-    assert len(env.bodies()) == 3
-    body = next(filter(lambda body: body.info().position.x > 100.0, env.bodies()))
-    env.remove_body(body)
-    assert len(env.bodies()) == 2
-
-
-def test_eating(env: CircleForaging) -> None:
-    """
-    Confirm that eating detection (collision of an agent to a food) correctly works.
-    Initially, food (F) and agent (A) are placed like
-    A  F
-
-    A  A
-    , and we add force only to the lower right agent.
-    """
-    handler = DebugLogHandler()
-    body = next(filter(lambda body: body.info().position.x > 100.0, env.bodies()))
-    body._body.angle = 0.0
-    food = next(iter(env._foods.keys()))
-    actions = {body: np.array([0.1, 0.1])}
-    already_ate = False
-
-    while True:
-        _ = env.step(actions)
-        observation = env.observe(body)
-
-        if already_ate:
-            if "created" in handler:
-                break
-        else:
-            if "eaten" in handler:
-                assert_almost_equal(observation.collision[1], 1.0)
-                already_ate = True
-            else:
-                assert observation.collision[1] == 0.0
-
-        if already_ate:
-            continue
-
-        distance_to_food = (
-            food.position.y - body.info().position.y - AGENT_RADIUS - FOOD_RADIUS
-        )
-        if SENSOR_LENGTH < distance_to_food:
-            assert_almost_equal(observation.sensor[1], 0.0)
-        else:
-            alpha = max(0.0, distance_to_food / SENSOR_LENGTH)
-            assert_either_a_or_b(observation.sensor[1], 1.0 - alpha, 0.0)
-
-    assert handler.once("eaten")
-    assert handler.once("created")
-
-
-def test_encounts(env: CircleForaging) -> None:
-    """
-    Confirm that encount detection (collision between agents) correctly works.
-    Again, food (F) and agent (A) are placed like
-    A  F
-
-    A  A
-    , and we add forces to two agents on the left, so that they collide.
-    """
-    body_higher, body_lower = None, None
-    for body in env.bodies():
-        pos = body.info().position
-        if pos.x < 100 and 100 < pos.y:
-            body_higher = body
-        elif pos.x < 100 and pos.y < 100:
-            body_lower = body
-
-    assert body_higher is not None and body_lower is not None
-    body_higher._body.angle = np.pi
-    body_lower._body.angle = np.pi
-    actions = {body_higher: np.array([0.1, 0.1]), body_lower: np.array([0.1, 0.1])}
-
-    while True:
-        encounts = env.step(actions)
-        obs_high = env.observe(body_higher)
-        obs_low = env.observe(body_lower)
-        # Test touch sensor
-        distance = body_higher.info().position.y - body_lower.info().position.y
-
-        # Test encount
-        if len(encounts) > 0:
-            assert_almost_equal(obs_low.collision[0], 1.0)
-            assert_almost_equal(obs_high.collision[0], 1.0)
-            assert len(encounts) == 1
-            a, b = encounts[0]
-            assert (body_higher is a and body_lower is b) or (
-                body_lower is a and body_higher is b
-            )
-            break
-        else:
-            assert_almost_equal(obs_low.collision[0], 0.0)
-            assert_almost_equal(obs_high.collision[0], 0.0)
-
-        if SENSOR_LENGTH + AGENT_RADIUS * 2 < distance:
-            assert_almost_equal(obs_low.sensor[0], 0.0)
-            assert_almost_equal(obs_high.sensor[0], 0.0)
-        else:
-            alpha = max(0.0, (distance - AGENT_RADIUS * 2) / SENSOR_LENGTH)
-            assert_either_a_or_b(obs_low.sensor[0], 1.0 - alpha, 0.0)
-            assert_either_a_or_b(obs_high.sensor[0], 1.0 - alpha, 0.0)
-
-
-def test_static(env: CircleForaging) -> None:
-    """
-    Confirm that collision detection to walls correctly works.
-    Again, food (F) and agent (A) are placed like
-    A  F
-
-    A  A
-    , and we push the lower right agent to the lower wall.
-    """
-    body = next(filter(lambda body: body.info().position.x > 100.0, env.bodies()))
-    # Go right
-    body._body.angle = np.pi
-    actions = {body: np.array([0.1, 0.1])}
-
-    while True:
-        _ = env.step(actions)
-        observation = env.observe(body)
-        distance_to_wall = body.info().position.y - AGENT_RADIUS - env._WALL_RADIUS
-
-        if SENSOR_LENGTH < distance_to_wall:
-            assert_almost_equal(observation.sensor[2], 0.0)
-        else:
-            alpha = max(0.0, distance_to_wall / SENSOR_LENGTH)
-            assert_either_a_or_b(observation.sensor[2], 1.0 - alpha, 0.0)
-
-        # Collision
-        abs_v = body._body.velocity.length
-        if distance_to_wall < abs_v * DT:
-            if np.abs(1.0 - observation.collision[2]) < 1e-6:
-                break
-        else:
-            assert_almost_equal(observation.collision[2], 0.0)
-
-
-def test_observe(env: CircleForaging) -> None:
-    """
-    Test the observation shape
-    """
-    body = env.bodies()[0]
-
-    _ = env.step({body: np.array([0.0, -1.0])})
-    observation = env.observe(body)
-    assert np.asarray(observation).shape == (3 * N_SENSORS + 3 + 2 + 3,)
-
-
-def test_can_place(env: CircleForaging) -> None:
-    """Test that invalid position is correctly rejected"""
-    assert not env._can_place(Vec2d(-10.0, -10.0), 1.0)
-    assert not env._can_place(Vec2d(0.0, 0.0), 1.0)
-    assert not env._can_place(Vec2d(0.9, 0.9), 1.0)
-    assert env._can_place(Vec2d(1.5, 1.5), 1.0)
-    assert not env._can_place(Vec2d(200.0, 200.0), 1.0)
-    assert not env._can_place(Vec2d(220.0, 220.0), 1.0)
-    assert not env._can_place(Vec2d(198.6, 198.6), 1.0)
-    assert env._can_place(Vec2d(198.5, 198.5), 1.0)
-    assert not env._can_place(Vec2d(50.0, 48.0), 5.0)
-    assert env._can_place(Vec2d(50.0, 48.0), 4.0)
-
-
-def test_energy_fn(env: CircleForaging) -> None:
-    """
-    Test the observation shape
-    """
-    bodies = env.bodies()
-    for body in bodies:
-        observation = env.observe(body)
-        assert body.index == observation.energy
diff --git a/tests/test_manager.py b/tests/test_manager.py
deleted file mode 100644
index 2f9f9857..00000000
--- a/tests/test_manager.py
+++ /dev/null
@@ -1,160 +0,0 @@
-from __future__ import annotations
-
-from functools import partial
-from typing import Callable
-
-import pytest
-
-from emevo import Encount, Status
-from emevo import birth_and_death as bd
-from emevo._test_utils import FakeBody
-
-DEFAULT_ENERGY_LEVEL: int = 10
-
-
-@pytest.fixture
-def status_fn():
-    return partial(Status, age=1, energy=DEFAULT_ENERGY_LEVEL)
-
-
-@pytest.fixture
-def hazard_fn() -> bd.death.HazardFunction:
-    return bd.death.Deterministic(0.5, 100.0)
-
-
-def _add_bodies(manager, n_bodies: int = 5) -> None:
-    for _ in range(n_bodies):
-        manager.register(FakeBody())
-
-
-def test_asexual(
-    status_fn: Callable[[], Status],
-    hazard_fn: Callable[[Status], float],
-) -> None:
-    """Test the most basic setting: Asexual reproduction + Oviparous birth"""
-
-    # 10 steps to death, 11 steps to birth, 3 steps to newborn
-    STEPS_TO_DEATH: int = DEFAULT_ENERGY_LEVEL
-    STEPS_TO_BIRTH: int = 3
-
-    manager = bd.AsexualReprManager(
-        initial_status_fn=status_fn,
-        hazard_fn=hazard_fn,
-        birth_fn=lambda status: float(
-            status.energy > DEFAULT_ENERGY_LEVEL + STEPS_TO_DEATH
-        ),
-        produce_fn=lambda status, body: bd.Oviparous(
-            parent=body,
-            parental_status=status,
-            time_to_birth=STEPS_TO_BIRTH,
-        ),
-    )
-    _add_bodies(manager)
-
-    bodies = list(manager.available_bodies())
-    for step_idx in range(STEPS_TO_DEATH):
-        for body_idx, body in enumerate(bodies):
-            status = manager.update_status(
-                body,
-                energy_delta=-1.0 if body_idx % 2 == 1 else 1.0,
-            )
-            if body_idx % 2 == 1:
-                assert status.energy == DEFAULT_ENERGY_LEVEL - step_idx - 1.0
-            else:
-                assert status.energy == DEFAULT_ENERGY_LEVEL + step_idx + 1.0
-        parents = manager.reproduce(bodies)
-        assert len(parents) == 0
-        deads, newborns = manager.step()
-        if step_idx == STEPS_TO_DEATH - 1:
-            assert len(deads) == 2
-            assert len(newborns) == 0
-            for dead in deads:
-                assert dead.body not in manager._statuses
-                bodies.remove(dead.body)
-        else:
-            assert len(deads) == 0, f"{step_idx}"
-            assert len(newborns) == 0
-
-    for body in bodies:
-        manager.update_status(body, energy_delta=1.0)
-
-    parents = manager.reproduce(bodies)
-    for body in bodies:
-        assert body in parents
-
-    for step_idx in range(STEPS_TO_BIRTH):
-        _, newborns = manager.step()
-        if step_idx == STEPS_TO_BIRTH - 1:
-            assert len(newborns) == 3
-        else:
-            assert len(newborns) == 0
-
-
-@pytest.mark.parametrize("newborn_cls", [bd.Oviparous, bd.Viviparous])
-def test_sexual(
-    status_fn: Callable[[], Status],
-    hazard_fn: Callable[[Status], float],
-    newborn_cls: type[bd.Newborn],
-) -> None:
-    """Test Sexual reproduction"""
-
-    # 10 steps to death, 11 steps to birth, 3 steps to newborn
-    STEPS_TO_DEATH: int = 10
-    STEPS_TO_BIRTH: int = 3
-
-    def success_prob(status_a: Status, status_b: Status) -> float:
-        threshold = float(DEFAULT_ENERGY_LEVEL + STEPS_TO_DEATH)
-        if status_a.energy > threshold and status_b.energy > threshold:
-            return 1.0
-        else:
-            return 0.0
-
-    def produce(sa: Status, sb: Status, encount: Encount) -> bd.Newborn:
-        return newborn_cls(
-            parent=encount.a,
-            parental_status=(sa, sb),
-            time_to_birth=STEPS_TO_BIRTH,
-        )
-
-    manager = bd.SexualReprManager(
-        initial_status_fn=status_fn,
-        hazard_fn=hazard_fn,
-        birth_fn=success_prob,
-        produce_fn=produce,
-    )
-
-    _add_bodies(manager)
-
-    bodies = list(manager.available_bodies())
-    for step_idx in range(STEPS_TO_DEATH):
-        for body_idx, body in enumerate(bodies):
-            status = manager.update_status(
-                body,
-                energy_delta=-1.0 if body_idx % 2 == 1 else 1.0,
-            )
-            if body_idx % 2 == 1:
-                assert status.energy == DEFAULT_ENERGY_LEVEL - step_idx - 1.0
-            else:
-                assert status.energy == DEFAULT_ENERGY_LEVEL + step_idx + 1.0
-        deads, newborns = manager.step()
-        if step_idx == STEPS_TO_DEATH - 1:
-            assert len(deads) == 2
-            assert len(newborns) == 0
-            for dead in deads:
-                assert dead.body not in manager._statuses
-                bodies.remove(dead.body)
-        else:
-            assert len(deads) == 0
-            assert len(newborns) == 0
-
-    for body in bodies:
-        manager.update_status(body, energy_delta=1.0)
-
-    assert len(manager.reproduce(Encount(bodies[0], bodies[1]))) == 1
-
-    for step_idx in range(STEPS_TO_BIRTH):
-        _, newborns = manager.step()
-        if step_idx == STEPS_TO_BIRTH - 1:
-            assert len(newborns) == 1
-        else:
-            assert len(newborns) == 0
diff --git a/tests/test_spaces.py b/tests/test_spaces.py
index 5b72c9df..a067cf90 100644
--- a/tests/test_spaces.py
+++ b/tests/test_spaces.py
@@ -1,66 +1,67 @@
 from typing import NamedTuple
 
-import numpy as np
+import chex
+import jax
+import jax.numpy as jnp
 import pytest
 from numpy.testing import assert_array_almost_equal
-from numpy.typing import NDArray
 
 from emevo.spaces import BoxSpace, DiscreteSpace, NamedTupleSpace
 
 
 @pytest.fixture
-def gen() -> np.random.Generator:
-    return np.random.Generator(np.random.PCG64())
+def key() -> chex.PRNGKey:
+    return jax.random.PRNGKey(43)
 
 
-def test_box(gen: np.random.Generator) -> None:
+def test_box(key: chex.PRNGKey) -> None:
+    key1, key2 = jax.random.split(key)
     N = 5
-    box_01 = BoxSpace(low=np.zeros(N), high=np.ones(N))
-    sampled = box_01.sample(gen)
-    assert 0 <= np.min(sampled) and np.max(sampled) <= 1.0
+    box_01 = BoxSpace(low=jnp.zeros(N), high=jnp.ones(N))
+    sampled = box_01.sample(key1)
+    assert 0 <= jnp.min(sampled) and jnp.max(sampled) <= 1.0
     assert box_01.is_bounded()
-    unclipped = np.array([-1, 0, 0.5, 1, 2])
+    unclipped = jnp.array([-1, 0, 0.5, 1, 2])
     clipped = box_01.clip(unclipped)
-    assert_array_almost_equal(clipped, np.array([0, 0, 0.5, 1, 1]))
-    assert box_01.contains(np.ones(N, dtype=np.float32) * 0.5)
-    assert not box_01.contains(np.ones(N, dtype=np.float64) * 0.5)
-    assert not box_01.contains(np.ones(N, dtype=np.float32) * 1.2)
+    assert_array_almost_equal(clipped, jnp.array([0, 0, 0.5, 1, 1]))
+    assert box_01.contains(jnp.ones(N, dtype=jnp.float32) * 0.5)
+    assert not box_01.contains(jnp.ones(N, dtype=jnp.float32) * 1.2)
 
-    box_0_inf = BoxSpace(low=np.zeros(N), high=np.ones(N) * np.inf)
-    sampled = box_0_inf.sample(gen)
-    assert 0 <= np.min(sampled)
+    box_0_inf = BoxSpace(low=jnp.zeros(N), high=jnp.ones(N) * jnp.inf)
+    sampled = box_0_inf.sample(key2)
+    assert 0 <= jnp.min(sampled)
     assert not box_0_inf.is_bounded()
     clipped = box_0_inf.clip(unclipped)
-    assert_array_almost_equal(clipped, np.array([0, 0, 0.5, 1, 2]))
+    assert_array_almost_equal(clipped, jnp.array([0, 0, 0.5, 1, 2]))
 
 
-def test_discrete(gen: np.random.Generator) -> None:
+def test_discrete(key: chex.PRNGKey) -> None:
     disc = DiscreteSpace(10)
     assert disc.contains(8)
     assert not disc.contains(-1)
     assert not disc.contains(10)
-    sampled = disc.sample(gen)
+    sampled = disc.sample(key)
     assert 0 <= sampled and sampled < 10
 
 
-def test_namedtuple(gen: np.random.Generator) -> None:
-    space1 = BoxSpace(low=np.zeros(10), high=np.ones(10))
-    space2 = BoxSpace(low=np.ones(3) * 0.5, high=np.ones(3))
+def test_namedtuple(key: chex.PRNGKey) -> None:
+    space1 = BoxSpace(low=jnp.zeros(10), high=jnp.ones(10))
+    space2 = BoxSpace(low=jnp.ones(3) * 0.5, high=jnp.ones(3))
 
     class Observation(NamedTuple):
-        sensor: NDArray
-        speed: NDArray
+        sensor: jax.Array
+        speed: jax.Array
 
     nt = NamedTupleSpace(Observation, sensor=space1, speed=space2)
-    sampled: Observation = nt.sample(gen)
-    assert 0 <= np.min(sampled.sensor) and np.max(sampled.sensor) <= 1.0
-    assert 0.5 <= np.min(sampled.speed) and np.max(sampled.speed) < 1.0
+    sampled: Observation = nt.sample(key)
+    assert 0 <= jnp.min(sampled.sensor) and jnp.max(sampled.sensor) <= 1.0
+    assert 0.5 <= jnp.min(sampled.speed) and jnp.max(sampled.speed) < 1.0
 
     assert nt.contains(
-        (np.ones(10, dtype=np.float32) * 0.5, np.ones(3, dtype=np.float32) * 0.8),
+        (jnp.ones(10, dtype=jnp.float32) * 0.5, jnp.ones(3, dtype=jnp.float32) * 0.8),
     )
     assert not nt.contains(
-        (np.ones(10, dtype=np.float32) * 0.5, np.ones(3, dtype=np.float32) * 1.2),
+        (jnp.ones(10, dtype=jnp.float32) * 0.5, jnp.ones(3, dtype=jnp.float32) * 1.2),
     )
     flattened = nt.flatten()
     assert flattened.shape == (13,)
diff --git a/tests/test_status.py b/tests/test_status.py
index a0bca1b7..500461d6 100644
--- a/tests/test_status.py
+++ b/tests/test_status.py
@@ -1,17 +1,21 @@
-from __future__ import annotations
-
+import jax.numpy as jnp
 import pytest
 
-from emevo.status import Status
+from emevo.status import init_status
 
 
-@pytest.mark.parametrize("capacity", (10, 100))
-def test_status(capacity: float) -> None:
-    status = Status(age=0.0, energy=0.0, capacity=capacity)
+@pytest.mark.parametrize(
+    "n, capacity",
+    [(1, 10.0), (1, 100.0), (10, 10.0), (10, 100.0)],
+)
+def test_status_clipping(n: int, capacity: float) -> None:
+    status = init_status(n=n, max_n=n, init_energy=0.0, capacity=capacity)
     for _ in range(200):
-        status.update(energy_delta=1.0)
-        assert status.energy >= 0.0 and status.energy <= capacity
+        status.update(energy_delta=jnp.ones(n))
+        assert jnp.all(status.energy >= 0.0)
+        assert jnp.all(status.energy <= capacity)
 
     for _ in range(300):
-        status.update(energy_delta=-1.0)
-        assert status.energy >= 0.0 and status.energy <= capacity
+        status.update(energy_delta=jnp.ones(n) * -1.0)
+        assert jnp.all(status.energy >= 0.0)
+        assert jnp.all(status.energy <= capacity)
diff --git a/tests/test_survival_prob.py b/tests/test_survival_prob.py
deleted file mode 100644
index 9a379ae5..00000000
--- a/tests/test_survival_prob.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import numpy as np
-import pytest
-
-from emevo import birth_and_death as bd
-from emevo.birth_and_death.population import cumulative_hazard
-from emevo.status import Status
-
-THRESHOLD: float = 1e-4
-
-
-@pytest.mark.parametrize(
-    "hazard_fn",
-    [
-        bd.death.SimplifiedGompertz(),
-        bd.death.SeparatedGompertz(),
-        bd.death.Constant(),
-        bd.death.EnergyLogistic(),
-        bd.death.Gompertz(),
-    ],
-)
-def test_survival_prob(hazard_fn: bd.death.HazardFunction) -> None:
-    for age in [100, 1000, 10000]:
-        for energy in [0.0, 5.0, 10.0]:
-            status = Status(age=age, energy=energy)
-            analytical_solution = hazard_fn.survival(status)
-            numerical_cum_h = cumulative_hazard(hazard_fn, energy=energy, max_age=age)
-            numerical_solution = np.exp(-numerical_cum_h)
-            print(hazard_fn.cumulative(status), numerical_cum_h)
-            assert (
-                abs(analytical_solution - numerical_solution) < THRESHOLD
-            ), f"Age: {age} Energy: {energy}"

From 59e928d4ad4e8c268bad748fac176800bf38e718 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 16 Oct 2023 18:02:18 +0900
Subject: [PATCH 021/337] test_env_utils

---
 src/emevo/environments/utils/food_repr.py |  8 ++++----
 tests/test_env_utils.py                   | 23 +++++++++++++++++++++++
 2 files changed, 27 insertions(+), 4 deletions(-)
 create mode 100644 tests/test_env_utils.py

diff --git a/src/emevo/environments/utils/food_repr.py b/src/emevo/environments/utils/food_repr.py
index 9dba022f..5948d90d 100644
--- a/src/emevo/environments/utils/food_repr.py
+++ b/src/emevo/environments/utils/food_repr.py
@@ -17,7 +17,7 @@
     InitLocFn,
     init_loc_gaussian,
     init_loc_gaussian_mixture,
-    init_loc_pre_defined,
+    init_loc_choice,
     init_loc_uniform,
 )
 
@@ -156,9 +156,9 @@ def __call__(
 class ReprLoc(str, enum.Enum):
     """Methods to determine the location of new foods or agents"""
 
+    CHOICE = "choice"
     GAUSSIAN = "gaussian"
     GAUSSIAN_MIXTURE = "gaussian-mixture"
-    PRE_DIFINED = "pre-defined"
     SWITCHING = "switching"
     UNIFORM = "uniform"
 
@@ -168,8 +168,8 @@ def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprLocFn, Any]:
             return _wrap_initloc(init_loc_gaussian(*args, **kwargs)), state
         elif self is ReprLoc.GAUSSIAN_MIXTURE:
             return _wrap_initloc(init_loc_gaussian_mixture(*args, **kwargs)), state
-        elif self is ReprLoc.PRE_DIFINED:
-            return _wrap_initloc(init_loc_pre_defined(*args, **kwargs)), state
+        elif self is ReprLoc.CHOICE:
+            return _wrap_initloc(init_loc_choice(*args, **kwargs)), state
         elif self is ReprLoc.SWITCHING:
             return ReprLocSwitching(*args, **kwargs), state
         elif self is ReprLoc.UNIFORM:
diff --git a/tests/test_env_utils.py b/tests/test_env_utils.py
new file mode 100644
index 00000000..fd856a5e
--- /dev/null
+++ b/tests/test_env_utils.py
@@ -0,0 +1,23 @@
+import chex
+import jax
+import jax.numpy as jnp
+import pytest
+
+from emevo.environments.phyjax2d import normalize
+from emevo.environments.utils.food_repr import ReprLoc
+from emevo.environments.utils.locating import CircleCoordinate, InitLoc
+
+
+@pytest.fixture
+def key() -> chex.PRNGKey:
+    return jax.random.PRNGKey(43)
+
+
+def test_circle_coordinate(key: chex.PRNGKey) -> None:
+    center = 3.0, 3.0
+    circle = CircleCoordinate(center, 3.0)
+    assert circle.contains_circle(jnp.array([3.0, 2.0]), jnp.array(1.1)).item()
+    arr = circle.uniform(jax.random.PRNGKey(10))
+    _, dist = normalize(arr - jnp.array(center))
+    assert dist.item() <= 3.0
+    jax.vmap(circle.uniform)(jax.random.split(key, 10))

From d149531fd704cfeba3c5bbb38693d5941dbc3360 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 17 Oct 2023 12:58:37 +0900
Subject: [PATCH 022/337] Test coordinates

---
 src/emevo/environments/utils/locating.py |  4 ++--
 tests/test_env_utils.py                  | 30 +++++++++++++++++-------
 2 files changed, 24 insertions(+), 10 deletions(-)

diff --git a/src/emevo/environments/utils/locating.py b/src/emevo/environments/utils/locating.py
index 73c266ed..b7abb222 100644
--- a/src/emevo/environments/utils/locating.py
+++ b/src/emevo/environments/utils/locating.py
@@ -59,12 +59,12 @@ class SquareCoordinate(Coordinate):
     def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]:
         return self.xlim, self.ylim
 
-    def contains_circle(self, center: jax.Array, radius: jax.Array) -> bool:
+    def contains_circle(self, center: jax.Array, radius: jax.Array) -> jax.Array:
         xmin, xmax = self.xlim
         ymin, ymax = self.ylim
         low = jnp.array([xmin, ymin]) + radius
         high = jnp.array([xmax, ymax]) - radius
-        return jnp.logical_and(low <= center, center <= high)
+        return jnp.logical_and(jnp.all(low <= center), jnp.all(center <= high))
 
     def uniform(self, key: chex.PRNGKey) -> jax.Array:
         xmin, xmax = self.xlim
diff --git a/tests/test_env_utils.py b/tests/test_env_utils.py
index fd856a5e..632405d3 100644
--- a/tests/test_env_utils.py
+++ b/tests/test_env_utils.py
@@ -5,7 +5,11 @@
 
 from emevo.environments.phyjax2d import normalize
 from emevo.environments.utils.food_repr import ReprLoc
-from emevo.environments.utils.locating import CircleCoordinate, InitLoc
+from emevo.environments.utils.locating import (
+    CircleCoordinate,
+    InitLoc,
+    SquareCoordinate,
+)
 
 
 @pytest.fixture
@@ -14,10 +18,20 @@ def key() -> chex.PRNGKey:
 
 
 def test_circle_coordinate(key: chex.PRNGKey) -> None:
-    center = 3.0, 3.0
-    circle = CircleCoordinate(center, 3.0)
-    assert circle.contains_circle(jnp.array([3.0, 2.0]), jnp.array(1.1)).item()
-    arr = circle.uniform(jax.random.PRNGKey(10))
-    _, dist = normalize(arr - jnp.array(center))
-    assert dist.item() <= 3.0
-    jax.vmap(circle.uniform)(jax.random.split(key, 10))
+    circle = CircleCoordinate((3.0, 3.0), 3.0)
+    assert circle.contains_circle(jnp.array([3.0, 2.0]), jnp.array(1.0)).item()
+    assert not circle.contains_circle(jnp.array([5.0, 0.0]), jnp.array(1.0)).item()
+    arr = jax.vmap(circle.uniform)(jax.random.split(key, 10))
+    chex.assert_shape(arr, (10, 2))
+    bigger_circle = CircleCoordinate((3.0, 3.0), 4.0)
+    assert jnp.all(jax.vmap(bigger_circle.contains_circle)(arr, jnp.ones(10)))
+
+
+def test_square_coordinate(key: chex.PRNGKey) -> None:
+    square = SquareCoordinate((-2.0, 2.0), (1.0, 4.0))
+    assert square.contains_circle(jnp.array([0.0, 3.0]), jnp.array(1.0)).item()
+    assert not square.contains_circle(jnp.array([0.0, 4.0]), jnp.array(1.0)).item()
+    arr = jax.vmap(square.uniform)(jax.random.split(key, 10))
+    chex.assert_shape(arr, (10, 2))
+    bigger_square = SquareCoordinate((-3.0, 3.0), (0.0, 5.0))
+    assert jnp.all(jax.vmap(bigger_square.contains_circle)(arr, jnp.ones(10))), arr

From baf531b437271ca8df893d2f310d92ae45a2b72e Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 17 Oct 2023 15:14:54 +0900
Subject: [PATCH 023/337] Test for food num/loc

---
 src/emevo/environments/utils/food_repr.py | 35 +++++-----
 tests/test_env_utils.py                   | 84 ++++++++++++++++++++++-
 2 files changed, 99 insertions(+), 20 deletions(-)

diff --git a/src/emevo/environments/utils/food_repr.py b/src/emevo/environments/utils/food_repr.py
index 5948d90d..ffb38856 100644
--- a/src/emevo/environments/utils/food_repr.py
+++ b/src/emevo/environments/utils/food_repr.py
@@ -32,13 +32,10 @@ class FoodNumState:
     def appears(self) -> jax.Array:
         return (self.internal - self.current) >= 1.0
 
-    def eaten(self, n: jax.Array) -> Self:
+    def eaten(self, n: int | jax.Array) -> Self:
         return self.replace(current=self.current - n, internal=self.internal - n)
 
-    def fail(self, n: int = 1) -> Self:
-        return self.replace(internal=self.internal - n)
-
-    def recover(self, n: int = 1) -> Self:
+    def recover(self, n: int | jax.Array = 1) -> Self:
         return self.replace(current=self.current + n)
 
 
@@ -54,8 +51,9 @@ class ReprNumConstant:
     initial: int
 
     def __call__(self, state: FoodNumState) -> FoodNumState:
+        internal = jnp.fmax(state.current, state.internal)
         diff = jnp.clip(self.initial - state.current, a_min=0)
-        state = state.replace(internal=state.internal + diff)
+        state = state.replace(internal=internal + diff)
         return state
 
 
@@ -66,7 +64,8 @@ class ReprNumLinear:
 
     def __call__(self, state: FoodNumState) -> FoodNumState:
         # Increase the number of foods by dn_dt
-        internal = jnp.clip(state.internal + self.dn_dt, a_max=float(self.initial))
+        internal = jnp.fmax(state.current, state.internal)
+        internal = jnp.clip(internal + self.dn_dt, a_max=float(self.initial))
         return state.replace(internal=internal)
 
 
@@ -77,8 +76,9 @@ class ReprNumLogistic:
     capacity: float
 
     def __call__(self, state: FoodNumState) -> FoodNumState:
-        dn_dt = self.growth_rate * state.internal * (1 - state.internal / self.capacity)
-        return state.replace(internal=state.internal + dn_dt)
+        internal = jnp.fmax(state.current, state.internal)
+        dn_dt = self.growth_rate * internal * (1 - internal / self.capacity)
+        return state.replace(internal=internal + dn_dt)
 
 
 class ReprNum(str, enum.Enum):
@@ -100,11 +100,11 @@ def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn, FoodNumState]:
             internal=jnp.array(float(initial)),
         )
         if self is ReprNum.CONSTANT:
-            fn = ReprNumConstant(**kwargs)
+            fn = ReprNumConstant(*args, **kwargs)
         elif self is ReprNum.LINEAR:
-            fn = ReprNumLinear(**kwargs)
+            fn = ReprNumLinear(*args, **kwargs)
         elif self is ReprNum.LOGISTIC:
-            fn = ReprNumLogistic(**kwargs)
+            fn = ReprNumLogistic(*args, **kwargs)
         else:
             raise AssertionError("Unreachable")
         return fn, state
@@ -121,8 +121,8 @@ def step(self) -> Self:
 ReprLocFn = Callable[[chex.PRNGKey, ReprLocState], jax.Array]
 
 
-def _wrap_initloc(fn: InitLocFn) -> ReprLocState:
-    return lambda key, state: (fn(key), state)
+def _wrap_initloc(fn: InitLocFn) -> ReprLocFn:
+    return lambda key, _: fn(key)
 
 
 class ReprLocSwitching:
@@ -146,11 +146,10 @@ def __call__(
         self,
         key: chex.PRNGKey,
         state: ReprLocState,
-    ) -> tuple[jax.Array, ReprLocState]:
-        count = state.count + 1
+    ) -> jax.Array:
+        count = state.n_produced + 1
         index = (count // self._interval) % self._n
-        result = jax.lax.switch(index, self._locfn_list, key)
-        return result, state.replace(count=count)
+        return jax.lax.switch(index, self._locfn_list, key)
 
 
 class ReprLoc(str, enum.Enum):
diff --git a/tests/test_env_utils.py b/tests/test_env_utils.py
index 632405d3..52ae7975 100644
--- a/tests/test_env_utils.py
+++ b/tests/test_env_utils.py
@@ -3,8 +3,7 @@
 import jax.numpy as jnp
 import pytest
 
-from emevo.environments.phyjax2d import normalize
-from emevo.environments.utils.food_repr import ReprLoc
+from emevo.environments.utils.food_repr import ReprLoc, ReprNum
 from emevo.environments.utils.locating import (
     CircleCoordinate,
     InitLoc,
@@ -35,3 +34,84 @@ def test_square_coordinate(key: chex.PRNGKey) -> None:
     chex.assert_shape(arr, (10, 2))
     bigger_square = SquareCoordinate((-3.0, 3.0), (0.0, 5.0))
     assert jnp.all(jax.vmap(bigger_square.contains_circle)(arr, jnp.ones(10))), arr
+
+
+def test_initloc_gaussian(key: chex.PRNGKey) -> None:
+    initloc_g = InitLoc.GAUSSIAN((3.0, 3.0), (1.0, 1.0))
+    loc = jax.vmap(initloc_g)(jax.random.split(key, 10))
+    chex.assert_shape(loc, (10, 2))
+    x_mean = jnp.mean(loc[:, 0])
+    y_mean = jnp.mean(loc[:, 1])
+    assert (x_mean - 3) ** 2 < 1.0 and (y_mean - 3) ** 2 < 1.0
+
+
+def test_initloc_uniform(key: chex.PRNGKey) -> None:
+    initloc_u = InitLoc.UNIFORM(CircleCoordinate((3.0, 3.0), 3.0))
+    loc = jax.vmap(initloc_u)(jax.random.split(key, 10))
+    chex.assert_shape(loc, (10, 2))
+    bigger_circle = CircleCoordinate((3.0, 3.0), 4.0)
+    assert jnp.all(jax.vmap(bigger_circle.contains_circle)(loc, jnp.ones(10)))
+
+
+def test_initloc_gm(key: chex.PRNGKey) -> None:
+    initloc_gm = InitLoc.GAUSSIAN_MIXTURE(
+        [0.3, 0.7],
+        ((0.0, 0.0), (10.0, 10.0)),
+        ((1.0, 1.0), (1.0, 1.0)),
+    )
+    loc = jax.vmap(initloc_gm)(jax.random.split(key, 20))
+    chex.assert_shape(loc, (20, 2))
+    x_mean = jnp.mean(loc[:, 0])
+    y_mean = jnp.mean(loc[:, 1])
+    assert (x_mean - 7) ** 2 < 1.0 and (y_mean - 7) ** 2 < 1.0
+
+
+def test_initloc_choice(key: chex.PRNGKey) -> None:
+    initloc_c = InitLoc.CHOICE([(0.0, 0.0), (1.0, 1.0), (2.0, 2.0)])
+    loc = jax.vmap(initloc_c)(jax.random.split(key, 20))
+    chex.assert_shape(loc, (20, 2))
+    c1 = loc == jnp.array([[0.0, 0.0]])
+    c2 = loc == jnp.array([[1.0, 1.0]])
+    c3 = loc == jnp.array([[2.0, 2.0]])
+    assert jnp.all(jnp.logical_or(c1, jnp.logical_or(c2, c3)))
+
+
+def test_reprloc_gaussian(key: chex.PRNGKey) -> None:
+    reprloc_g, state = ReprLoc.GAUSSIAN((3.0, 3.0), (1.0, 1.0))
+    loc = jax.vmap(reprloc_g)(
+        jax.random.split(key, 10),
+        jax.tree_map(lambda a: jnp.tile(a, (10,)), state),
+    )
+    chex.assert_shape(loc, (10, 2))
+    x_mean = jnp.mean(loc[:, 0])
+    y_mean = jnp.mean(loc[:, 1])
+    assert (x_mean - 3) ** 2 < 1.0 and (y_mean - 3) ** 2 < 1.0
+
+
+def test_reprloc_switching(key: chex.PRNGKey) -> None:
+    initloc_g = InitLoc.GAUSSIAN((3.0, 3.0), (1.0, 1.0))
+    initloc_u = InitLoc.UNIFORM(CircleCoordinate((3.0, 3.0), 3.0))
+    reprloc_s, state = ReprLoc.SWITCHING(10, initloc_g, initloc_u)
+    loc = jax.vmap(reprloc_s)(
+        jax.random.split(key, 10),
+        jax.tree_map(lambda a: jnp.tile(a, (10,)), state),
+    )
+    chex.assert_shape(loc, (10, 2))
+    x_mean = jnp.mean(loc[:, 0])
+    y_mean = jnp.mean(loc[:, 1])
+    assert (x_mean - 3) ** 2 < 1.0 and (y_mean - 3) ** 2 < 1.0
+
+    loc = jax.vmap(reprloc_s)(
+        jax.random.split(key, 10),
+        jax.tree_map(lambda a: jnp.tile(a * 10, (10,)), state),
+    )
+    chex.assert_shape(loc, (10, 2))
+    bigger_circle = CircleCoordinate((3.0, 3.0), 4.0)
+    assert jnp.all(jax.vmap(bigger_circle.contains_circle)(loc, jnp.ones(10)))
+
+
+def test_foodnum_const() -> None:
+    const, state = ReprNum.CONSTANT(10)
+    assert const(state.eaten(3)).appears()
+    assert const(state.eaten(3).recover(2)).appears()
+    assert not const(state.eaten(3).recover(3)).appears()

From ccbe9901330af8fcfa1b9fc7bff38b4a188f917b Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 17 Oct 2023 19:13:00 +0900
Subject: [PATCH 024/337] Implement env initialization

---
 src/emevo/environments/circle_foraging.py    | 231 +++++++++++++++++--
 src/emevo/environments/placement.py          |   8 +-
 src/emevo/environments/pymunk_envs/circle.py |   2 +
 src/emevo/environments/utils/food_repr.py    |   6 +-
 4 files changed, 227 insertions(+), 20 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 9166025b..b199aacf 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -1,25 +1,36 @@
-from typing import Callable, Literal, NamedTuple
+import warnings
+from typing import Any, Callable, Literal, NamedTuple, TypeVar
 
+import chex
 import jax
 import jax.numpy as jnp
 import numpy as np
 
 from emevo.env import Env
-from emevo.environments.phyjax2d import Position, Space, State, StateDict
+from emevo.environments.phyjax2d import Circle, Position, Space, State, StateDict
 from emevo.environments.phyjax2d_utils import (
     SpaceBuilder,
     make_approx_circle,
     make_square,
 )
-from emevo.environments.utils.food_repr import ReprLoc, ReprLocFn, ReprNum, ReprNumFn
+from emevo.environments.placement import _inf_xy, place_agent, place_food
+from emevo.environments.utils.food_repr import (
+    FoodNumState,
+    ReprLoc,
+    ReprLocFn,
+    ReprLocState,
+    ReprNum,
+    ReprNumFn,
+)
 from emevo.environments.utils.locating import (
     CircleCoordinate,
-    Coordinate,
     InitLoc,
     InitLocFn,
     SquareCoordinate,
 )
 
+FN = TypeVar("FN")
+
 
 class CFObs(NamedTuple):
     """Observation of an agent."""
@@ -44,6 +55,27 @@ def __array__(self) -> jax.Array:
         )
 
 
+@chex.dataclass
+class CFState:
+    physics: StateDict
+    food_num: FoodNumState
+    repr_loc: ReprLocState
+
+
+def _get_num_or_loc_fn(
+    arg: str | tuple | FN,
+    enum_type: Callable[..., Callable[..., Any]],
+    default_args: dict[str, tuple[Any, ...]],
+) -> Any:
+    if isinstance(arg, str):
+        return enum_type(arg)(*default_args[arg])
+    elif isinstance(arg, tuple) or isinstance(arg, list):
+        name, *args = arg
+        return enum_type(name)(*args)
+    else:
+        return arg
+
+
 def _make_space(
     dt: float,
     coordinate: CircleCoordinate | SquareCoordinate,
@@ -87,7 +119,7 @@ def _make_space(
         # Use the default density for now
         builder.add_circle(radius=agent_radius, friction=0.1, elasticity=0.2)
     for _ in range(n_max_foods):
-        builder.add_circle(radius=food_radius, friction=0.0, elasticity=0.0)
+        builder.add_circle(radius=food_radius, friction=0.0, elasticity=0.2)
     space = builder.build()
     return space, seg_state
 
@@ -95,10 +127,12 @@ def _make_space(
 class CircleForaging(Env):
     def __init__(
         self,
-        n_initial_bodies: int = 6,
+        n_initial_agents: int = 6,
+        n_max_agents: int = 100,
+        n_max_foods: int = 100,
         food_num_fn: ReprNumFn | str | tuple[str, ...] = "constant",
         food_loc_fn: ReprLocFn | str | tuple[str, ...] = "gaussian",
-        body_loc_fn: InitLocFn | str | tuple[str, ...] = "uniform",
+        agent_loc_fn: InitLocFn | str | tuple[str, ...] = "uniform",
         xlim: tuple[float, float] = (0.0, 200.0),
         ylim: tuple[float, float] = (0.0, 200.0),
         env_radius: float = 120.0,
@@ -108,23 +142,192 @@ def __init__(
         sensor_length: float = 10.0,
         sensor_range: tuple[float, float] = (-180.0, 180.0),
         agent_radius: float = 12.0,
-        agent_mass: float = 1.0,
-        agent_friction: float = 0.1,
         food_radius: float = 4.0,
-        food_mass: float = 0.1,
-        food_friction: float = 0.0,
         foodloc_interval: int = 1000,
         max_abs_impulse: float = 0.2,
         dt: float = 0.05,
-        damping: float = 1.0,
+        linear_damping: float = 0.9,
+        angular_damping: float = 0.8,
+        n_velocity_iter: int = 6,
+        n_position_iter: int = 2,
         n_physics_steps: int = 5,
         max_place_attempts: int = 10,
-        body_elasticity: float = 0.4,
-        nofriction: bool = False,
     ) -> None:
+        # Coordinate and range
         if env_shape == "square":
             self._coordinate = SquareCoordinate(xlim, ylim)
         elif env_shape == "circle":
             self._coordinate = CircleCoordinate((env_radius, env_radius), env_radius)
         else:
             raise ValueError(f"Unsupported env_shape {env_shape}")
+
+        self._xlim, self._ylim = self._coordinate.bbox()
+        self._x_range = self._xlim[1] - self._xlim[0]
+        self._y_range = self._ylim[1] - self._ylim[0]
+        # Food and body placing functions
+        self._agent_radius = agent_radius
+        self._food_radius = food_radius
+        self._food_loc_fn, self._initial_foodloc_state = self._make_food_loc_fn(
+            food_loc_fn
+        )
+        self._food_num_fn, self._initial_foodnum_state = self._make_food_num_fn(
+            food_num_fn
+        )
+        self._agent_loc_fn = self._make_agent_loc_fn(agent_loc_fn)
+        self._foodloc_interval = foodloc_interval
+        # Initial numbers
+        assert n_max_agents > n_initial_agents
+        assert n_max_foods > self._food_num_fn.initial
+        self._n_initial_agents = n_initial_agents
+        self._n_max_agents = n_max_agents
+        self._n_initial_foods = self._food_num_fn.initial
+        self._n_max_foods = n_max_foods
+        self._max_place_attempts = max_place_attempts
+        # Physics
+        self._space, self._segment_state = _make_space(
+            dt=dt,
+            coordinate=self._coordinate,
+            linear_damping=linear_damping,
+            angular_damping=angular_damping,
+            n_velocity_iter=n_velocity_iter,
+            n_position_iter=n_position_iter,
+            n_max_agents=n_max_agents,
+            n_max_foods=n_max_foods,
+            agent_radius=agent_radius,
+            food_radius=food_radius,
+        )
+        self._agent_indices = jnp.arange(n_max_agents)
+        self._food_indices = jnp.arange(n_max_foods)
+        self._n_physics_steps = n_physics_steps
+
+    @staticmethod
+    def _make_food_num_fn(
+        food_num_fn: str | tuple | ReprNumFn,
+    ) -> tuple[ReprNumFn, FoodNumState]:
+        return _get_num_or_loc_fn(
+            food_num_fn,
+            ReprNum,  # type: ignore
+            {"constant": (10,), "linear": (10, 0.01), "logistic": (8, 1.2, 12)},
+        )
+
+    def _make_food_loc_fn(
+        self,
+        food_loc_fn: str | tuple | ReprLocFn,
+    ) -> tuple[ReprLocFn, ReprLocState]:
+        return _get_num_or_loc_fn(
+            food_loc_fn,
+            ReprLoc,  # type: ignore
+            {
+                "gaussian": (
+                    (self._xlim[1] * 0.75, self._ylim[1] * 0.75),
+                    (self._x_range * 0.1, self._y_range * 0.1),
+                ),
+                "gaussian-mixture": (
+                    [0.5, 0.5],
+                    [
+                        (self._xlim[1] * 0.75, self._ylim[1] * 0.75),
+                        (self._xlim[1] * 0.25, self._ylim[1] * 0.75),
+                    ],
+                    [(self._x_range * 0.1, self._y_range * 0.1)] * 2,
+                ),
+                "switching": (
+                    self._foodloc_interval,
+                    (
+                        "gaussian",
+                        (self._xlim[1] * 0.75, self._ylim[1] * 0.75),
+                        (self._x_range * 0.1, self._y_range * 0.1),
+                    ),
+                    (
+                        "gaussian",
+                        (self._xlim[1] * 0.25, self._ylim[1] * 0.75),
+                        (self._x_range * 0.1, self._y_range * 0.1),
+                    ),
+                ),
+                "uniform": (self._coordinate,),
+            },
+        )
+
+    def _make_agent_loc_fn(self, init_loc_fn: str | tuple | InitLocFn) -> InitLocFn:
+        return _get_num_or_loc_fn(
+            init_loc_fn,
+            InitLoc,  # type: ignore
+            {
+                "gaussian": (
+                    (self._xlim[1] * 0.25, self._ylim[1] * 0.25),
+                    (self._x_range * 0.3, self._y_range * 0.3),
+                ),
+                "uniform": (self._coordinate,),
+            },
+        )
+
+    def set_food_num_fn(self, food_num_fn: str | tuple | ReprNumFn) -> None:
+        self._food_num_fn = self._make_food_num_fn(food_num_fn)
+
+    def set_food_loc_fn(self, food_loc_fn: str | tuple | ReprLocFn) -> None:
+        self._food_loc_fn = self._make_food_loc_fn(food_loc_fn)
+
+    def set_agent_loc_fn(self, agent_loc_fn: str | tuple | InitLocFn) -> None:
+        self._agent_loc_fn = self._make_agent_loc_fn(agent_loc_fn)
+
+    def reset(self, key: chex.PRNGKey) -> CFState:
+        pass
+
+    def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
+        stated = self._space.shaped.zeros_state()
+        circle = stated.circle
+        assert circle is not None
+        circle_xy = circle.p.xy
+
+        circle_isactive = jnp.concatenate(
+            (
+                jnp.ones(self._n_initial_agents, dtype=bool),
+                jnp.zeros(self._n_max_agents - self._n_initial_agents, dtype=bool),
+                jnp.ones(self._n_initial_foods, dtype=bool),
+                jnp.zeros(self._n_max_foods - self._n_initial_foods, dtype=bool),
+            )
+        )
+        stated = stated.replace(circle=stated.circle.replace(is_active=circle_isactive))  # type: ignore
+        keys = jax.random.split(key, self._n_initial_foods + self._n_initial_agents)
+        agent_failed = 0
+        for i, key in enumerate(keys[: self._n_initial_foods]):
+            xy = place_agent(
+                n_trial=self._max_place_attempts,
+                agent_radius=self._agent_radius,
+                coordinate=self._coordinate,
+                initloc_fn=self._agent_loc_fn,
+                key=key,
+                shaped=self._space.shaped,
+                stated=stated,
+            )
+            if jnp.all(xy < _inf_xy):
+                circle_xy = circle_xy.at[i].set(xy)
+                circle = circle.replace(p=circle.p.replace(xy=circle_xy))  # type: ignore
+            else:
+                agent_failed += 1
+
+        if agent_failed > 0:
+            warnings.warn(f"Failed to place {agent_failed} agents!")
+
+        food_failed = 0
+        foodloc_state = self._initial_foodloc_state
+        for i, key in enumerate(keys[self._n_initial_foods :]):
+            xy = place_food(
+                n_trial=self._max_place_attempts,
+                food_radius=self._food_radius,
+                coordinate=self._coordinate,
+                reprloc_fn=self._food_loc_fn,  # type: ignore
+                reprloc_state=foodloc_state,
+                key=key,
+                shaped=self._space.shaped,
+                stated=stated,
+            )
+            if jnp.all(xy < _inf_xy):
+                circle_xy = circle_xy.at[i + self._n_max_agents].set(xy)
+                circle = circle.replace(p=circle.p.replace(xy=circle_xy))  # type: ignore
+            else:
+                food_failed += 1
+
+        if food_failed > 0:
+            warnings.warn(f"Failed to place {food_failed} foods!")
+
+        return stated.replace(circle=circle, segment=self._segment_state)
diff --git a/src/emevo/environments/placement.py b/src/emevo/environments/placement.py
index e7ffd122..4e364fb2 100644
--- a/src/emevo/environments/placement.py
+++ b/src/emevo/environments/placement.py
@@ -9,6 +9,8 @@
 from emevo.environments.utils.food_repr import ReprLocFn, ReprLocState
 from emevo.environments.utils.locating import Coordinate, InitLocFn
 
+_inf_xy = jnp.array([jnp.inf, jnp.inf])
+
 
 def _place_common(
     coordinate: Coordinate,
@@ -26,7 +28,7 @@ def step_fun(state: jax.Array, xi: tuple[jax.Array, jax.Array]):
         is_ok, loc = xi
         return jax.lax.select(is_ok, loc, state), None
 
-    return jax.lax.scan(step_fun, jnp.array([jnp.inf, jnp.inf]), (ok, locations))[0]
+    return jax.lax.scan(step_fun, _inf_xy, (ok, locations))[0]
 
 
 def place_food(
@@ -44,9 +46,9 @@ def place_food(
     loc_fn = jax.vmap(reprloc_fn, in_axes=(0, None), out_axes=(0, None))
     locations = loc_fn(keys, reprloc_state)
     return _place_common(
+        coordinate,
         shaped,
         stated,
-        coordinate,
         locations,
         jnp.ones(n_trial) * food_radius,
     )
@@ -65,9 +67,9 @@ def place_agent(
     keys = jax.random.split(key, n_trial)
     locations = jax.vmap(initloc_fn)(keys)
     return _place_common(
+        coordinate,
         shaped,
         stated,
-        coordinate,
         locations,
         jnp.ones(n_trial) * agent_radius,
     )
diff --git a/src/emevo/environments/pymunk_envs/circle.py b/src/emevo/environments/pymunk_envs/circle.py
index 3fe9ba56..f9c3ea7f 100644
--- a/src/emevo/environments/pymunk_envs/circle.py
+++ b/src/emevo/environments/pymunk_envs/circle.py
@@ -26,6 +26,8 @@
 
 FN = TypeVar("FN")
 
+
+
 class CFObs(NamedTuple):
     """Observation of an agent."""
 
diff --git a/src/emevo/environments/utils/food_repr.py b/src/emevo/environments/utils/food_repr.py
index ffb38856..b365d60f 100644
--- a/src/emevo/environments/utils/food_repr.py
+++ b/src/emevo/environments/utils/food_repr.py
@@ -96,8 +96,8 @@ def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn, FoodNumState]:
         else:
             raise ValueError("'initial' is required for all ReprNum functions")
         state = FoodNumState(  # type: ignore
-            current=jnp.array(int(initial)),
-            internal=jnp.array(float(initial)),
+            current=jnp.array(int(initial), dtype=jnp.int32),
+            internal=jnp.array(float(initial), dtype=jnp.float32),
         )
         if self is ReprNum.CONSTANT:
             fn = ReprNumConstant(*args, **kwargs)
@@ -162,7 +162,7 @@ class ReprLoc(str, enum.Enum):
     UNIFORM = "uniform"
 
     def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprLocFn, Any]:
-        state = ReprLocState(n_produced=jnp.array(0))
+        state = ReprLocState(n_produced=jnp.array(0, dtype=jnp.int32))
         if self is ReprLoc.GAUSSIAN:
             return _wrap_initloc(init_loc_gaussian(*args, **kwargs)), state
         elif self is ReprLoc.GAUSSIAN_MIXTURE:

From ff391af01d88d29e0c8dee78e19e03b7bfe2dbef Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 18 Oct 2023 09:59:45 +0900
Subject: [PATCH 025/337] Implement reset

---
 src/emevo/environments/circle_foraging.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index b199aacf..a43e4b51 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -7,7 +7,7 @@
 import numpy as np
 
 from emevo.env import Env
-from emevo.environments.phyjax2d import Circle, Position, Space, State, StateDict
+from emevo.environments.phyjax2d import Position, Space, State, StateDict
 from emevo.environments.phyjax2d_utils import (
     SpaceBuilder,
     make_approx_circle,
@@ -270,7 +270,10 @@ def set_agent_loc_fn(self, agent_loc_fn: str | tuple | InitLocFn) -> None:
         self._agent_loc_fn = self._make_agent_loc_fn(agent_loc_fn)
 
     def reset(self, key: chex.PRNGKey) -> CFState:
-        pass
+        stated = self._initialize_physics_state(key)
+        repr_loc = self._initial_foodloc_state
+        food_num = self._initial_foodnum_state
+        return CFState(physics=stated, repr_loc=repr_loc, food_num=food_num)
 
     def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
         stated = self._space.shaped.zeros_state()
@@ -306,7 +309,7 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
                 agent_failed += 1
 
         if agent_failed > 0:
-            warnings.warn(f"Failed to place {agent_failed} agents!")
+            warnings.warn(f"Failed to place {agent_failed} agents!", stacklevel=1)
 
         food_failed = 0
         foodloc_state = self._initial_foodloc_state
@@ -328,6 +331,6 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
                 food_failed += 1
 
         if food_failed > 0:
-            warnings.warn(f"Failed to place {food_failed} foods!")
+            warnings.warn(f"Failed to place {food_failed} foods!", stacklevel=1)
 
         return stated.replace(circle=circle, segment=self._segment_state)

From 6c7ecb982c4c918ecf666e3a299287bea2777841 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 18 Oct 2023 10:57:37 +0900
Subject: [PATCH 026/337] vis

---
 smoke-tests/circle_loop.py                    |  47 +-
 src/emevo/env.py                              |   4 +-
 src/emevo/environments/__init__.py            |  11 +-
 src/emevo/environments/circle_foraging.py     |  40 +-
 src/emevo/environments/phyjax2d.py            |  13 +-
 .../environments/pymunk_envs/moderngl_vis.py  | 574 ++++++++++++++++++
 6 files changed, 639 insertions(+), 50 deletions(-)
 create mode 100644 src/emevo/environments/pymunk_envs/moderngl_vis.py

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index 7de459f4..4414e764 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -8,14 +8,10 @@
 import typer
 from numpy.random import PCG64
 from tqdm import tqdm
-
-from emevo import _test_utils as test_utils
+import jax
 from emevo import make
 
 
-class Rendering(str, enum.Enum):
-    PYGAME = "pygame"
-    MODERNGL = "moderngl"
 
 
 class FoodNum(str, enum.Enum):
@@ -26,8 +22,6 @@ class FoodNum(str, enum.Enum):
 
 def main(
     steps: int = 100,
-    render: Optional[Rendering] = None,
-    food_initial_force: Tuple[float, float] = (0.0, 0.0),
     seed: int = 1,
     n_foods: int = 10,
     n_foods_later: int = 10,
@@ -36,6 +30,7 @@ def main(
     use_test_env: bool = False,
     obstacles: bool = False,
     angle: bool = False,
+    render: bool = False,
     env_shape: str = "square",
     food_loc_fn: str = "gaussian",
     food_num: FoodNum = FoodNum.CONSTANT,
@@ -54,47 +49,27 @@ def main(
     else:
         env_kwargs = {"foodloc_interval": 20}
 
-    if obstacles:
-        env_kwargs["obstacles"] = [(100, 50, 100, 200)]
-
-    if angle:
-        env_kwargs["max_abs_angle"] = np.pi / 40
-
-    env_kwargs["damping"] = 0.8
-
-    if use_test_env:
-        env = test_utils.predefined_env(**env_kwargs, seed=seed)
-    else:
-        env_kwargs["food_num_fn"] = food_num.value
-        env_kwargs["food_loc_fn"] = food_loc_fn
-        env = make(
-            "CircleForaging-v0",
-            env_shape=env_shape,
-            food_initial_force=food_initial_force,
-            seed=seed,
-            **env_kwargs,
-        )
-    bodies = env.bodies()
-    gen = np.random.Generator(PCG64(seed=seed))
+    env = make(
+        "CircleForaging-v0",
+        env_shape=env_shape,
+        **env_kwargs,
+    )
+    state = env.reset(jax.random.PRNGKey(43))
 
     if render is not None:
-        visualizer = env.visualizer(mode=render.value)
-    else:
-        visualizer = None
+        visualizer = env.visualizer()
 
     change_foods = food_num is FoodNum.CONSTANT and n_foods_later != n_foods
 
     for i in tqdm(range(steps)):
-        actions = {body: body.act_space.sample(gen) for body in bodies}
+        # actions = {body: body.act_space.sample(gen) for body in bodies}
         # Samples for adding constant force for debugging
         # actions = {body: np.array([0.0, -1.0]) for body in bodies}
-        _ = env.step(actions)  # type: ignore
+        # _ = env.step(actions)  # type: ignore
         if visualizer is not None:
             visualizer.render(env)
             visualizer.show()
 
-        if change_foods and steps // 2 <= i:
-            env.set_food_num_fn(("constant", n_foods_later))  # type: ignore
 
 
 if __name__ == "__main__":
diff --git a/src/emevo/env.py b/src/emevo/env.py
index a750fe90..56eaecb4 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -55,7 +55,7 @@ def reset(self, key: chex.PRNGKey) -> STATE:
 
     @abc.abstractmethod
     def profile(self) -> Profile:
-        """Returns profile of all 'alive' agents in the! environment"""
+        """Returns profile of all 'alive' agents in the environment"""
         pass
 
     @abc.abstractmethod
@@ -87,6 +87,6 @@ def is_extinct(self, state: STATE) -> bool:
         pass
 
     @abc.abstractmethod
-    def visualizer(self, *args, **kwargs) -> Visualizer:
+    def visualizer(self, headless: bool = False, **kwargs) -> Visualizer:
         """Create a visualizer for the environment"""
         pass
diff --git a/src/emevo/environments/__init__.py b/src/emevo/environments/__init__.py
index 87a23755..27b317df 100644
--- a/src/emevo/environments/__init__.py
+++ b/src/emevo/environments/__init__.py
@@ -5,9 +5,10 @@
 # from emevo.environments.pymunk_envs import circle
 # from emevo.environments.pymunk_envs.circle import CFBody, CFObs, CircleForaging
 from emevo.environments.registry import description, make, register
+from emevo.environments.circle_foraging import CircleForaging
 
-# register(
-#     "CircleForaging-v0",
-#     circle.CircleForaging,
-#     "Pymunk circle foraging environment",
-# )
+register(
+    "CircleForaging-v0",
+    CircleForaging,
+    "Phyjax2d circle foraging environment",
+)
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index a43e4b51..93952302 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -5,8 +5,9 @@
 import jax
 import jax.numpy as jnp
 import numpy as np
+from jax.typing import ArrayLike
 
-from emevo.env import Env
+from emevo.env import Env, Profile, Visualizer
 from emevo.environments.phyjax2d import Position, Space, State, StateDict
 from emevo.environments.phyjax2d_utils import (
     SpaceBuilder,
@@ -28,6 +29,7 @@
     InitLocFn,
     SquareCoordinate,
 )
+from emevo.types import Index
 
 FN = TypeVar("FN")
 
@@ -167,6 +169,7 @@ def __init__(
         # Food and body placing functions
         self._agent_radius = agent_radius
         self._food_radius = food_radius
+        self._foodloc_interval = foodloc_interval
         self._food_loc_fn, self._initial_foodloc_state = self._make_food_loc_fn(
             food_loc_fn
         )
@@ -174,7 +177,6 @@ def __init__(
             food_num_fn
         )
         self._agent_loc_fn = self._make_agent_loc_fn(agent_loc_fn)
-        self._foodloc_interval = foodloc_interval
         # Initial numbers
         assert n_max_agents > n_initial_agents
         assert n_max_foods > self._food_num_fn.initial
@@ -269,6 +271,21 @@ def set_food_loc_fn(self, food_loc_fn: str | tuple | ReprLocFn) -> None:
     def set_agent_loc_fn(self, agent_loc_fn: str | tuple | InitLocFn) -> None:
         self._agent_loc_fn = self._make_agent_loc_fn(agent_loc_fn)
 
+    def step(self, state: CFState, action: ArrayLike):
+        pass
+
+    def activate(self, state: CFState, index: Index) -> CFState:
+        pass
+
+    def deactivate(self, state: CFState, index: Index) -> CFState:
+        pass
+
+    def is_extinct(self, state: CFState) -> bool:
+        pass
+
+    def profile(self) -> Profile:
+        pass
+
     def reset(self, key: chex.PRNGKey) -> CFState:
         stated = self._initialize_physics_state(key)
         repr_loc = self._initial_foodloc_state
@@ -334,3 +351,22 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
             warnings.warn(f"Failed to place {food_failed} foods!", stacklevel=1)
 
         return stated.replace(circle=circle, segment=self._segment_state)
+
+    def visualizer(
+        self,
+        state: CFState,
+        headless: bool = False,
+        **kwargs,
+    ) -> Visualizer:
+        """Create a visualizer for the environment"""
+        from emevo.environments.pymunk_envs import moderngl_vis
+
+        return moderngl_vis.MglVisualizer(
+            x_range=self._x_range,
+            y_range=self._y_range,
+            space=self._space,
+            stated=state.physics,
+            figsize=figsize,
+            backend=mgl_backend,
+            **kwargs,
+        )
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 505604a3..2af01338 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -371,6 +371,12 @@ class Capsule(Shape):
     radius: jax.Array
 
 
+def _length_to_points(length: jax.Array) -> tuple[jax.Array, jax.Array]:
+    a = jnp.stack((length * -0.5, length * 0.0), axis=-1)
+    b = jnp.stack((length * 0.5, length * 0.0), axis=-1)
+    return a, b
+
+
 @chex.dataclass
 class Segment(Shape):
     length: jax.Array
@@ -386,11 +392,8 @@ def to_capsule(self) -> Capsule:
             radius=jnp.zeros_like(self.length),
         )
 
-
-def _length_to_points(length: jax.Array) -> tuple[jax.Array, jax.Array]:
-    a = jnp.stack((length * -0.5, length * 0.0), axis=-1)
-    b = jnp.stack((length * 0.5, length * 0.0), axis=-1)
-    return a, b
+    def get_ab(self) -> tuple[jax.Array, jax.Array]:
+        return _length_to_points(self.length)
 
 
 @jax.vmap
diff --git a/src/emevo/environments/pymunk_envs/moderngl_vis.py b/src/emevo/environments/pymunk_envs/moderngl_vis.py
new file mode 100644
index 00000000..2c908b6b
--- /dev/null
+++ b/src/emevo/environments/pymunk_envs/moderngl_vis.py
@@ -0,0 +1,574 @@
+"""
+A simple,  fast visualizer based on moderngl.
+Currently, only supports circles and lines.
+"""
+from __future__ import annotations
+
+from typing import Any, ClassVar, Iterable
+
+import moderngl as mgl
+import moderngl_window as mglw
+import numpy as np
+from moderngl_window.context import headless
+from numpy.typing import NDArray
+
+from emevo.environments.phyjax2d import Circle, Segment, Space, State, StateDict
+
+_CIRCLE_VERTEX_SHADER = """
+#version 330
+uniform mat4 proj;
+in vec2 in_position;
+in float in_scale;
+in vec4 in_color;
+out vec4 v_color;
+void main() {
+    gl_Position = proj * vec4(in_position, 0.0, 1.0);
+    gl_PointSize = in_scale;
+    v_color = in_color;
+}
+"""
+
+# Smoothing by fwidth is based on: https://rubendv.be/posts/fwidth/
+_CIRCLE_FRAGMENT_SHADER = """
+#version 330
+in vec4 v_color;
+out vec4 f_color;
+void main() {
+    float dist = length(gl_PointCoord.xy - vec2(0.5));
+    float delta = fwidth(dist);
+    float alpha = smoothstep(0.45, 0.45 - delta, dist);
+    f_color = v_color * alpha;
+}
+"""
+
+_LINE_VERTEX_SHADER = """
+#version 330
+in vec2 in_position;
+uniform mat4 proj;
+void main() {
+    gl_Position = proj * vec4(in_position, 0.0, 1.0);
+}
+"""
+
+_LINE_GEOMETRY_SHADER = """
+#version 330
+layout (lines) in;
+layout (triangle_strip, max_vertices = 4) out;
+uniform float width;
+void main() {
+    vec2 a = gl_in[0].gl_Position.xy;
+    vec2 b = gl_in[1].gl_Position.xy;
+    vec2 a2b = b - a;
+    vec2 a2left = vec2(-a2b.y, a2b.x) / length(a2b) * width;
+
+    vec4 positions[4] = vec4[4](
+        vec4(a - a2left, 0.0, 1.0),
+        vec4(a + a2left, 0.0, 1.0),
+        vec4(b - a2left, 0.0, 1.0),
+        vec4(b + a2left, 0.0, 1.0)
+    );
+    for (int i = 0; i < 4; ++i) {
+        gl_Position = positions[i];
+        EmitVertex();
+    }
+    EndPrimitive();
+}
+"""
+
+_LINE_FRAGMENT_SHADER = """
+#version 330
+out vec4 f_color;
+uniform vec4 color;
+void main() {
+    f_color = color;
+}
+"""
+
+
+_ARROW_GEOMETRY_SHADER = """
+#version 330
+layout (lines) in;
+layout (triangle_strip, max_vertices = 7) out;
+uniform mat4 proj;
+void main() {
+    vec2 a = gl_in[0].gl_Position.xy;
+    vec2 b = gl_in[1].gl_Position.xy;
+    vec2 a2b = b - a;
+    float a2b_len = length(a2b);
+    float width = min(0.004, a2b_len * 0.12);
+    vec2 a2left = vec2(-a2b.y, a2b.x) / length(a2b) * width;
+    vec2 c = a + a2b * 0.5;
+    vec2 c2head = a2left * 2.5;
+
+    vec4 positions[7] = vec4[7](
+        vec4(a - a2left, 0.0, 1.0),
+        vec4(a + a2left, 0.0, 1.0),
+        vec4(c - a2left, 0.0, 1.0),
+        vec4(c + a2left, 0.0, 1.0),
+        vec4(c - c2head, 0.0, 1.0),
+        vec4(b, 0.0, 1.0),
+        vec4(c + c2head, 0.0, 1.0)
+    );
+    for (int i = 0; i < 7; ++i) {
+        gl_Position = positions[i];
+        EmitVertex();
+    }
+    EndPrimitive();
+}
+"""
+
+_TEXTURE_VERTEX_SHADER = """
+#version 330
+uniform mat4 proj;
+in vec2 in_position;
+in vec2 in_uv;
+out vec2 uv;
+void main() {
+    gl_Position = proj * vec4(in_position, 0.0, 1.0);
+    uv = in_uv;
+}
+"""
+
+_TEXTURE_FRAGMENT_SHADER = """
+#version 330
+uniform sampler2D image;
+in vec2 uv;
+out vec4 f_color;
+void main() {
+    f_color = vec4(texture(image, uv).rgb, 1.0);
+}
+"""
+
+
+class Renderable:
+    MODE: ClassVar[int]
+    vertex_array: mgl.VertexArray
+
+    def render(self) -> None:
+        self.vertex_array.render(mode=self.MODE)
+
+
+class CircleVA(Renderable):
+    MODE = mgl.POINTS
+
+    def __init__(
+        self,
+        ctx: mgl.Context,
+        program: mgl.Program,
+        points: NDArray,
+        scales: NDArray,
+        colors: NDArray,
+    ) -> None:
+        self._ctx = ctx
+        self._length = points.shape[0]
+        self._points = ctx.buffer(reserve=len(points) * 4 * 2 * 10)
+        self._scales = ctx.buffer(reserve=len(scales) * 4 * 10)
+        self._colors = ctx.buffer(reserve=len(colors) * 4 * 4 * 10)
+
+        self.vertex_array = ctx.vertex_array(
+            program,
+            [
+                (self._points, "2f", "in_position"),
+                (self._scales, "f", "in_scale"),
+                (self._colors, "4f", "in_color"),
+            ],
+        )
+        self.update(points, scales, colors)
+
+    def update(self, points: NDArray, scales: NDArray, colors: NDArray) -> bool:
+        length = points.shape[0]
+        if self._length != length:
+            self._length = length
+            self._points.orphan(length * 4 * 2)
+            self._scales.orphan(length * 4)
+            self._colors.orphan(length * 4 * 4)
+        self._points.write(points)
+        self._scales.write(scales)
+        self._colors.write(colors)
+        return length > 0
+
+
+class SegmentVA(Renderable):
+    MODE = mgl.LINES
+
+    def __init__(
+        self,
+        ctx: mgl.Context,
+        program: mgl.Program,
+        segments: NDArray,
+    ) -> None:
+        self._ctx = ctx
+        self._length = segments.shape[0]
+        self._segments = ctx.buffer(reserve=len(segments) * 4 * 2 * 10)
+
+        self.vertex_array = ctx.vertex_array(
+            program,
+            [(self._segments, "2f", "in_position")],
+        )
+        self.update(segments)
+
+    def update(self, segments: NDArray) -> bool:
+        length = segments.shape[0]
+        if self._length != length:
+            self._length = length
+            self._segments.orphan(length * 4 * 2)
+        self._segments.write(segments)
+        return length > 0
+
+
+class TextureVA(Renderable):
+    MODE = mgl.TRIANGLE_STRIP
+
+    def __init__(
+        self,
+        ctx: mgl.Context,
+        program: mgl.Program,
+        texture: mgl.Texture,
+    ) -> None:
+        self._ctx = ctx
+        self._texture = texture
+        quad_mat = np.array(
+            # x, y, u, v
+            [
+                [0, 1, 0, 1],  # upper left
+                [0, 0, 0, 0],  # lower left
+                [1, 1, 1, 1],  # upper right
+                [1, 0, 1, 0],  # lower right
+            ],
+            dtype=np.float32,
+        )
+        quad_mat_buffer = ctx.buffer(data=quad_mat)
+        self.vertex_array = ctx.vertex_array(
+            program,
+            [(quad_mat_buffer, "2f 2f", "in_position", "in_uv")],
+        )
+
+    def update(self, image: bytes) -> None:
+        self._texture.write(image)
+        self._texture.use()
+
+
+def _collect_circles(
+    circle: Circle,
+    state: State,
+    circle_scaling: float,
+) -> tuple[NDArray, NDArray, NDArray]:
+    points = state.p.xy
+    scales = circle.radius * circle_scaling
+    colors = circle.rgba
+    return (
+        np.array(points, dtype=np.float32),
+        np.array(scales, dtype=np.float32),
+        np.array(colors, dtype=np.float32) / 255.0,
+    )
+
+
+def _collect_static_lines(segment: Segment, state: State) -> NDArray:
+    points = []
+    a, b = segment.get_ab()
+    a = state.p.transform(a)
+    b = state.p.transform(b)
+    for ai, bi in zip(a, b):
+        points.append(ai)
+        points.append(bi)
+    return np.array(points, dtype=np.float32)
+
+
+def _get_clip_ranges(lengthes: list[float]) -> list[tuple[float, float]]:
+    """Clip ranges to [-1, 1]"""
+    total = sum(lengthes)
+    res = []
+    left = -1.0
+    for length in lengthes:
+        right = left + 2.0 * length / total
+        res.append((left, right))
+        left = right
+    return res
+
+
+class MglRenderer:
+    """Render pymunk environments to the given moderngl context."""
+
+    def __init__(
+        self,
+        context: mgl.Context,
+        screen_width: int,
+        screen_height: int,
+        x_range: float,
+        y_range: float,
+        space: Space,
+        stated: StateDict,
+        voffsets: tuple[int, ...] = (),
+        hoffsets: tuple[int, ...] = (),
+    ) -> None:
+        self._context = context
+
+        self._screen_x = _get_clip_ranges([screen_width, *hoffsets])
+        self._screen_y = _get_clip_ranges([screen_height, *voffsets])
+        self._x_range, self._y_range = x_range, y_range
+        self._range_min = min(x_range, y_range)
+        if x_range < y_range:
+            self._range_min = x_range
+            self._circle_scaling = screen_width / x_range * 2
+        else:
+            self._range_min = y_range
+            self._circle_scaling = screen_height / y_range * 2
+
+        self._space = space
+        circle_program = self._make_gl_program(
+            vertex_shader=_CIRCLE_VERTEX_SHADER,
+            fragment_shader=_CIRCLE_FRAGMENT_SHADER,
+        )
+        points, scales, colors = _collect_circles(
+            space.shaped.circle,
+            stated.circle,
+            self._circle_scaling,
+        )
+        self._circles = CircleVA(
+            ctx=context,
+            program=circle_program,
+            points=points,
+            scales=scales,
+            colors=colors,
+        )
+        static_segment_program = self._make_gl_program(
+            vertex_shader=_LINE_VERTEX_SHADER,
+            geometry_shader=_LINE_GEOMETRY_SHADER,
+            fragment_shader=_LINE_FRAGMENT_SHADER,
+            color=np.array([0.0, 0.0, 0.0, 0.4], dtype=np.float32),
+            width=np.array([0.004], dtype=np.float32),
+        )
+        self._static_lines = SegmentVA(
+            ctx=context,
+            program=static_segment_program,
+            segments=_collect_static_lines(space.shaped.segment, stated.segment),
+        )
+        # head_program = self._make_gl_program(
+        #     vertex_shader=_LINE_VERTEX_SHADER,
+        #     geometry_shader=_LINE_GEOMETRY_SHADER,
+        #     fragment_shader=_LINE_FRAGMENT_SHADER,
+        #     color=np.array([0.5, 0.0, 1.0, 1.0], dtype=np.float32),
+        #     width=np.array([0.004], dtype=np.float32),
+        # )
+        # self._heads = SegmentVA(
+        #     ctx=context,
+        #     program=head_program,
+        #     segments=_collect_heads(shapes),
+        # )
+        self._overlays = {}
+
+    def _make_gl_program(
+        self,
+        vertex_shader: str,
+        geometry_shader: str | None = None,
+        fragment_shader: str | None = None,
+        screen_idx: tuple[int, int] = (0, 0),
+        game_x: tuple[float, float] | None = None,
+        game_y: tuple[float, float] | None = None,
+        **kwargs: NDArray,
+    ) -> mgl.Program:
+        self._context.enable(mgl.PROGRAM_POINT_SIZE | mgl.BLEND)
+        self._context.blend_func = mgl.DEFAULT_BLENDING
+        prog = self._context.program(
+            vertex_shader=vertex_shader,
+            geometry_shader=geometry_shader,
+            fragment_shader=fragment_shader,
+        )
+        proj = _make_projection_matrix(
+            game_x=game_x or (0, self._x_range),
+            game_y=game_y or (0, self._y_range),
+            screen_x=self._screen_x[screen_idx[0]],
+            screen_y=self._screen_y[screen_idx[1]],
+        )
+        prog["proj"].write(proj)  # type: ignore
+        for key, value in kwargs.items():
+            prog[key].write(value)  # type: ignore
+        return prog
+
+    def overlay(self, name: str, value: Any) -> Any:
+        """Render additional value as an overlay"""
+        key = name.lower()
+        if key == "arrow":
+            segments = _collect_policies(value, self._range_min * 0.1)
+            if "arrow" in self._overlays:
+                do_render = self._overlays["arrow"].update(segments)
+            else:
+                arrow_program = self._make_gl_program(
+                    vertex_shader=_LINE_VERTEX_SHADER,
+                    geometry_shader=_ARROW_GEOMETRY_SHADER,
+                    fragment_shader=_LINE_FRAGMENT_SHADER,
+                    color=np.array([0.98, 0.45, 0.45, 1.0], dtype=np.float32),
+                )
+                self._overlays["arrow"] = SegmentVA(
+                    ctx=self._context,
+                    program=arrow_program,
+                    segments=segments,
+                )
+                do_render = True
+            if do_render:
+                self._overlays["arrow"].render()
+        elif key.startswith("stack"):
+            xi, yi = map(int, key.split("-")[1:])
+            image = np.flipud(value)
+            h, w = image.shape[:2]
+            image_bytes = image.tobytes()
+            if key not in self._overlays:
+                texture = self._context.texture((w, h), 3, image_bytes)
+                texture.build_mipmaps()
+                program = self._make_gl_program(
+                    vertex_shader=_TEXTURE_VERTEX_SHADER,
+                    fragment_shader=_TEXTURE_FRAGMENT_SHADER,
+                    screen_idx=(xi, yi),
+                    game_x=(0.0, 1.0),
+                    game_y=(0.0, 1.0),
+                )
+                self._overlays[key] = TextureVA(self._context, program, texture)
+            self._overlays[key].update(image_bytes)
+            self._overlays[key].render()
+        else:
+            raise ValueError(f"Unsupported overlay in moderngl visualizer: {name}")
+
+    def render(self, stated: StateDict) -> None:
+        circles = _collect_circles(
+            space.shaped.circle,
+            stated.circle,
+            self._circle_scaling,
+        )
+        if self._circles.update(*circles):
+            self._circles.render()
+        # if self._heads.update(_collect_heads(shapes)):
+        #     self._heads.render()
+        # sensors = _collect_sensors(shapes)
+        # if self._sensors.update(sensors):
+        #     self._sensors.render()
+        self._static_lines.render()
+
+
+class MglVisualizer:
+    """
+    Visualizer class that follows the `emevo.Visualizer` protocol.
+    Considered as a main interface to use this visualizer.
+    """
+
+    def __init__(
+        self,
+        x_range: float,
+        y_range: float,
+        space: Space,
+        stated: StateDict,
+        figsize: tuple[float, float] | None = None,
+        voffsets: tuple[int, ...] = (),
+        hoffsets: tuple[int, ...] = (),
+        vsync: bool = False,
+        backend: str = "pyglet",
+        title: str = "EmEvo PymunkEnv",
+    ) -> None:
+        self.pix_fmt = "rgba"
+
+        if figsize is None:
+            figsize = x_range * 3.0, y_range * 3.0
+        w, h = int(figsize[0]), int(figsize[1])
+        self._figsize = w + int(sum(hoffsets)), h + int(sum(voffsets))
+
+        self._window = _make_window(
+            title=title,
+            size=self._figsize,
+            backend=backend,
+            vsync=vsync,
+        )
+        self._renderer = MglRenderer(
+            context=self._window.ctx,
+            screen_width=w,
+            screen_height=h,
+            x_range=x_range,
+            y_range=y_range,
+            space=space,
+            stated=stated,
+            voffsets=voffsets,
+            hoffsets=hoffsets,
+        )
+
+    def close(self) -> None:
+        self._window.close()
+
+    def get_image(self) -> NDArray:
+        output = np.frombuffer(
+            self._window.fbo.read(components=4, dtype="f1"),
+            dtype=np.uint8,
+        )
+        w, h = self._figsize
+        return output.reshape(h, w, -1)[::-1]
+
+    def overlay(self, name: str, value: Any) -> None:
+        self._renderer.overlay(name, value)
+
+    def render(self, stated: StateDict) -> None:
+        self._window.clear(1.0, 1.0, 1.0)
+        self._window.use()
+        self._renderer.render(stated=stated)
+
+    def show(self) -> None:
+        self._window.swap_buffers()
+
+
+class _EglHeadlessWindow(headless.Window):
+    name = "egl-headless"
+
+    def init_mgl_context(self) -> None:
+        """Create an standalone context and framebuffer"""
+        self._ctx = mgl.create_standalone_context(
+            require=self.gl_version_code,
+            backend="egl",  # type: ignore
+        )
+        self._fbo = self.ctx.framebuffer(
+            color_attachments=self.ctx.texture(self.size, 4, samples=self._samples),
+            depth_attachment=self.ctx.depth_texture(self.size, samples=self._samples),
+        )
+        self.use()
+
+
+def _make_window(
+    *,
+    title: str,
+    size: tuple[int, int],
+    backend: str,
+    **kwargs,
+) -> mglw.BaseWindow:
+    if backend == "headless":
+        window_cls = _EglHeadlessWindow
+    else:
+        window_cls = mglw.get_window_cls(f"moderngl_window.context.{backend}.Window")
+    window = window_cls(title=title, gl_version=(4, 1), size=size, **kwargs)
+    mglw.activate_context(ctx=window.ctx)
+    return window
+
+
+def _make_projection_matrix(
+    game_x: tuple[float, float] = (0.0, 1.0),
+    game_y: tuple[float, float] = (0.0, 1.0),
+    screen_x: tuple[float, float] = (-1.0, 1.0),
+    screen_y: tuple[float, float] = (-1.0, 1.0),
+) -> NDArray:
+    screen_width = screen_x[1] - screen_x[0]
+    screen_height = screen_y[1] - screen_y[0]
+    x_scale = screen_width / (game_x[1] - game_x[0])
+    y_scale = screen_height / (game_y[1] - game_y[0])
+    scale_mat = np.array(
+        [
+            [x_scale, 0, 0, 0],
+            [0, y_scale, 0, 0],
+            [0, 0, 0, 0],
+            [0, 0, 0, 1],
+        ],
+        dtype=np.float32,
+    )
+    trans_mat = np.array(
+        [
+            [1, 0, 0, (sum(screen_x) - sum(game_x)) / screen_width],
+            [0, 1, 0, (sum(screen_y) - sum(game_y)) / screen_height],
+            [0, 0, 1, 0],
+            [0, 0, 0, 1],
+        ],
+        dtype=np.float32,
+    )
+    return np.ascontiguousarray(np.dot(scale_mat, trans_mat).T)

From 5feb28f44120909dbf7d303a2a863f4ba8d2e979 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 18 Oct 2023 17:24:03 +0900
Subject: [PATCH 027/337] test_placement

---
 src/emevo/environments/circle_foraging.py | 12 +++---
 src/emevo/environments/phyjax2d_utils.py  | 15 +++----
 src/emevo/environments/placement.py       |  3 +-
 tests/test_placement.py                   | 50 +++++++++++++++++++++++
 4 files changed, 65 insertions(+), 15 deletions(-)
 create mode 100644 tests/test_placement.py

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 93952302..0f87f92a 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -1,5 +1,5 @@
 import warnings
-from typing import Any, Callable, Literal, NamedTuple, TypeVar
+from typing import Any, Callable, Literal, NamedTuple
 
 import chex
 import jax
@@ -14,7 +14,7 @@
     make_approx_circle,
     make_square,
 )
-from emevo.environments.placement import _inf_xy, place_agent, place_food
+from emevo.environments.placement import place_agent, place_food
 from emevo.environments.utils.food_repr import (
     FoodNumState,
     ReprLoc,
@@ -31,8 +31,6 @@
 )
 from emevo.types import Index
 
-FN = TypeVar("FN")
-
 
 class CFObs(NamedTuple):
     """Observation of an agent."""
@@ -65,7 +63,7 @@ class CFState:
 
 
 def _get_num_or_loc_fn(
-    arg: str | tuple | FN,
+    arg: str | tuple | list,
     enum_type: Callable[..., Callable[..., Any]],
     default_args: dict[str, tuple[Any, ...]],
 ) -> Any:
@@ -75,7 +73,7 @@ def _get_num_or_loc_fn(
         name, *args = arg
         return enum_type(name)(*args)
     else:
-        return arg
+        raise ValueError(f"Invalid value in _get_num_or_loc_fn {arg}")
 
 
 def _make_space(
@@ -319,7 +317,7 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
                 shaped=self._space.shaped,
                 stated=stated,
             )
-            if jnp.all(xy < _inf_xy):
+            if jnp.all(xy < jnp.inf):
                 circle_xy = circle_xy.at[i].set(xy)
                 circle = circle.replace(p=circle.p.replace(xy=circle_xy))  # type: ignore
             else:
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 5c83ce67..bf16f0ce 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -274,11 +274,11 @@ def circle_overwrap(
     if stated.circle is not None and shaped.circle is not None:
         cpos = stated.circle.p.xy
         # Suppose that cpos.shape == (N, 2) and xy.shape == (2,)
-        _, dist = jax.vmap(normalize)(cpos - jnp.expand_dims(xy, axis=0))
+        dist = jnp.linalg.norm(cpos - jnp.expand_dims(xy, axis=0), axis=-1)
         penetration = shaped.circle.radius + radius - dist
-        circle_overwrap = jnp.any(penetration >= 0)
+        overwrap2cir = jnp.any(penetration >= 0)
     else:
-        circle_overwrap = jnp.array(False)
+        overwrap2cir = jnp.array(False)
 
     # Circle-segment overwrap
 
@@ -287,16 +287,17 @@ def circle_overwrap(
         # Suppose that cpos.shape == (N, 2) and xy.shape == (2,)
         pb = spos.inv_transform(jnp.expand_dims(xy, axis=0))
         p1, p2 = _length_to_points(shaped.segment.length)
+        p1, p2 = jnp.squeeze(p1, axis=1), jnp.squeeze(p2, axis=1)
         edge = p2 - p1
         s1 = jnp.expand_dims(_vmap_dot(pb - p1, edge), axis=1)
         s2 = jnp.expand_dims(_vmap_dot(p2 - pb, edge), axis=1)
         in_segment = jnp.logical_and(s1 >= 0.0, s2 >= 0.0)
         ee = jnp.sum(jnp.square(edge), axis=-1, keepdims=True)
         pa = jnp.where(in_segment, p1 + edge * s1 / ee, jnp.where(s1 < 0.0, p1, p2))
-        _, dist = jax.vmap(normalize)(pb - pa)
+        dist = jnp.linalg.norm(pb - pa, axis=-1)
         penetration = radius - dist
-        segment_overwrap = jnp.any(penetration >= 0)
+        overwrap2seg = jnp.any(penetration >= 0)
     else:
-        segment_overwrap = jnp.array(False)
+        overwrap2seg = jnp.array(False)
 
-    return jnp.logical_or(circle_overwrap, segment_overwrap)
+    return jnp.logical_or(overwrap2cir, overwrap2seg)
diff --git a/src/emevo/environments/placement.py b/src/emevo/environments/placement.py
index 4e364fb2..fe99731c 100644
--- a/src/emevo/environments/placement.py
+++ b/src/emevo/environments/placement.py
@@ -10,6 +10,7 @@
 from emevo.environments.utils.locating import Coordinate, InitLocFn
 
 _inf_xy = jnp.array([jnp.inf, jnp.inf])
+_vmap_co = jax.vmap(circle_overwrap, in_axes=(None, None, 0, 0))
 
 
 def _place_common(
@@ -21,7 +22,7 @@ def _place_common(
 ) -> jax.Array:
     ok = jnp.logical_and(
         jax.vmap(coordinate.contains_circle)(locations, radius),
-        circle_overwrap(shaped, stated, locations, radius),
+        jnp.logical_not(_vmap_co(shaped, stated, locations, radius)),
     )
 
     def step_fun(state: jax.Array, xi: tuple[jax.Array, jax.Array]):
diff --git a/tests/test_placement.py b/tests/test_placement.py
new file mode 100644
index 00000000..5fc2b7f7
--- /dev/null
+++ b/tests/test_placement.py
@@ -0,0 +1,50 @@
+import chex
+import jax
+import jax.numpy as jnp
+import pytest
+
+from emevo.environments.circle_foraging import _make_space
+from emevo.environments.phyjax2d import Space, StateDict
+from emevo.environments.placement import place_agent
+from emevo.environments.utils.locating import CircleCoordinate, InitLoc
+
+N_MAX_AGENTS = 20
+N_MAX_FOODS = 10
+
+
+@pytest.fixture
+def key() -> chex.PRNGKey:
+    return jax.random.PRNGKey(43)
+
+
+def get_space_and_more() -> tuple[Space, StateDict, CircleCoordinate]:
+    coordinate = CircleCoordinate((100.0, 100.0), 100.0)
+    space, seg_state = _make_space(
+        0.1,
+        coordinate,
+        n_max_agents=N_MAX_AGENTS,
+        n_max_foods=N_MAX_FOODS,
+    )
+    stated = space.shaped.zeros_state().replace(segment=seg_state)
+    return space, stated, coordinate
+
+
+def test_place_agents(key) -> None:
+    n = N_MAX_AGENTS // 2
+    keys = jax.random.split(key, n)
+    space, stated, coordinate = get_space_and_more()
+    initloc_fn = InitLoc.GAUSSIAN((100.0, 100.0), (10.0, 10.0))
+
+    for i, key in enumerate(keys):
+        xy = place_agent(
+            n_trial=10,
+            agent_radius=6.0,
+            coordinate=coordinate,
+            initloc_fn=initloc_fn,
+            key=key,
+            shaped=space.shaped,
+            stated=stated,
+        )
+        assert jnp.all(xy < jnp.inf)
+        circle_xy = circle_xy.at[i].set(xy)
+        circle = circle.replace(p=circle.p.replace(xy=circle_xy))  # type: ignore

From 6697007cbc5f3462e51d08f6d2d51d818649f284 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 19 Oct 2023 16:29:04 +0900
Subject: [PATCH 028/337] Fix test_placement

---
 smoke-tests/circle_loop.py                    |  6 +-
 src/emevo/environments/circle_foraging.py     | 38 +++++++----
 src/emevo/environments/phyjax2d.py            | 32 +++++----
 src/emevo/environments/phyjax2d_utils.py      | 17 ++---
 src/emevo/environments/placement.py           |  2 +-
 .../environments/pymunk_envs/moderngl_vis.py  | 30 +++++----
 src/emevo/visualizer.py                       | 18 ++---
 tests/test_placement.py                       | 67 +++++++++++++++++--
 8 files changed, 142 insertions(+), 68 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index 4414e764..509fdf89 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -57,9 +57,7 @@ def main(
     state = env.reset(jax.random.PRNGKey(43))
 
     if render is not None:
-        visualizer = env.visualizer()
-
-    change_foods = food_num is FoodNum.CONSTANT and n_foods_later != n_foods
+        visualizer = env.visualizer(state)
 
     for i in tqdm(range(steps)):
         # actions = {body: body.act_space.sample(gen) for body in bodies}
@@ -67,7 +65,7 @@ def main(
         # actions = {body: np.array([0.0, -1.0]) for body in bodies}
         # _ = env.step(actions)  # type: ignore
         if visualizer is not None:
-            visualizer.render(env)
+            visualizer.render(state)
             visualizer.show()
 
 
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 0f87f92a..5914fa21 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -61,6 +61,10 @@ class CFState:
     food_num: FoodNumState
     repr_loc: ReprLocState
 
+    @property
+    def stated(self) -> StateDict:
+        return self.physics
+
 
 def _get_num_or_loc_fn(
     arg: str | tuple | list,
@@ -292,11 +296,9 @@ def reset(self, key: chex.PRNGKey) -> CFState:
 
     def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
         stated = self._space.shaped.zeros_state()
-        circle = stated.circle
-        assert circle is not None
-        circle_xy = circle.p.xy
+        assert stated.circle is not None
 
-        circle_isactive = jnp.concatenate(
+        is_active = jnp.concatenate(
             (
                 jnp.ones(self._n_initial_agents, dtype=bool),
                 jnp.zeros(self._n_max_agents - self._n_initial_agents, dtype=bool),
@@ -304,10 +306,15 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
                 jnp.zeros(self._n_max_foods - self._n_initial_foods, dtype=bool),
             )
         )
-        stated = stated.replace(circle=stated.circle.replace(is_active=circle_isactive))  # type: ignore
+        # Move all circle to the invisiable area
+        stated = stated.nested_replace(
+            "circle.p.xy",
+            jnp.ones_like(stated.circle.p.xy) * -100,
+        )
+        stated = stated.nested_replace("circle.is_active", is_active)
         keys = jax.random.split(key, self._n_initial_foods + self._n_initial_agents)
         agent_failed = 0
-        for i, key in enumerate(keys[: self._n_initial_foods]):
+        for i, key in enumerate(keys[: self._n_initial_agents]):
             xy = place_agent(
                 n_trial=self._max_place_attempts,
                 agent_radius=self._agent_radius,
@@ -318,8 +325,10 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
                 stated=stated,
             )
             if jnp.all(xy < jnp.inf):
-                circle_xy = circle_xy.at[i].set(xy)
-                circle = circle.replace(p=circle.p.replace(xy=circle_xy))  # type: ignore
+                stated = stated.nested_replace(
+                    "circle.p.xy",
+                    stated.circle.p.xy.at[i].set(xy),
+                )
             else:
                 agent_failed += 1
 
@@ -339,21 +348,24 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
                 shaped=self._space.shaped,
                 stated=stated,
             )
-            if jnp.all(xy < _inf_xy):
-                circle_xy = circle_xy.at[i + self._n_max_agents].set(xy)
-                circle = circle.replace(p=circle.p.replace(xy=circle_xy))  # type: ignore
+            if jnp.all(xy < jnp.inf):
+                stated = stated.nested_replace(
+                    "circle.p.xy",
+                    stated.circle.p.xy.at[i + self._n_max_agents].set(xy),
+                )
             else:
                 food_failed += 1
 
         if food_failed > 0:
             warnings.warn(f"Failed to place {food_failed} foods!", stacklevel=1)
 
-        return stated.replace(circle=circle, segment=self._segment_state)
+        return stated.replace(segment=self._segment_state)
 
     def visualizer(
         self,
         state: CFState,
-        headless: bool = False,
+        figsize: tuple[float, float] | None = None,
+        mgl_backend: str = "pyglet",
         **kwargs,
     ) -> Visualizer:
         """Create a visualizer for the environment"""
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 2af01338..193703ba 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -319,20 +319,6 @@ def init_solver(n: int) -> VelocitySolver:
     )
 
 
-def _pv_gather(
-    p1: _PositionLike,
-    p2: _PositionLike,
-    orig: _PositionLike,
-) -> _PositionLike:
-    indices = jnp.arange(len(orig.angle))
-    outer, inner = generate_self_pairs(indices)
-    p1_xy = jnp.zeros_like(orig.xy).at[outer].add(p1.xy)
-    p1_angle = jnp.zeros_like(orig.angle).at[outer].add(p1.angle)
-    p2_xy = jnp.zeros_like(orig.xy).at[inner].add(p2.xy)
-    p2_angle = jnp.zeros_like(orig.angle).at[inner].add(p2.angle)
-    return p1.__class__(xy=p1_xy + p2_xy, angle=p1_angle + p2_angle)
-
-
 def _vmap_dot(xy1: jax.Array, xy2: jax.Array) -> jax.Array:
     """Dot product between nested vectors"""
     chex.assert_equal_shape((xy1, xy2))
@@ -472,6 +458,17 @@ def update(self, statec: State) -> Self:
         capsule = self._get("capsule", statec)
         return self.__class__(circle=circle, segment=segment, capsule=capsule)
 
+    def nested_replace(self, query: str, value: Any) -> Self:
+        """Convenient method for nested replace"""
+        queries = query.split(".")
+        objects = [self]
+        for q in queries[:-1]:
+            objects.append(objects[-1][q])  # type: ignore
+        obj = objects[-1].replace(**{queries[-1]: value})  # type: ignore
+        for o, q in zip(objects[-2::-1], queries[-2::-1]):
+            obj = o.replace(**{q: obj})  # type: ignore
+        return obj
+
 
 @chex.dataclass
 class ShapeDict:
@@ -623,6 +620,13 @@ def check_contacts(self, stated: StateDict) -> ContactWithMetadata:
                     outer_index=outer_index + offset1,
                     inner_index=inner_index + offset2,
                 )
+                if jnp.any(contact.penetration >= 0.0):
+                    total_loop = 0
+                    for i in range(len1):
+                        for j in range(len2):
+                            if total_loop == 394:
+                                print(stated[n1].p.get_slice(i), stated[n2].p.get_slice(j))
+                            total_loop += 1
                 contacts.append(contact_with_meta)
         return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *contacts)
 
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index bf16f0ce..6001d9c0 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -189,16 +189,16 @@ def add_segment(
         self.segments.append(segment)
 
     def build(self) -> Space:
-        def stack_or(sl: list[Shape]) -> Shape | None:
+        def concat_or(sl: list[Shape]) -> Shape | None:
             if len(sl) > 0:
-                return jax.tree_map(lambda *args: jnp.stack(args), *sl)
+                return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *sl)
             else:
                 return None
 
         shaped = ShapeDict(
-            circle=stack_or(self.circles),
-            segment=stack_or(self.segments),
-            capsule=stack_or(self.capsules),
+            circle=concat_or(self.circles),
+            segment=concat_or(self.segments),
+            capsule=concat_or(self.capsules),
         )
         dt = self.dt
         linear_damping = jnp.exp(-dt * self.linear_damping).item()
@@ -276,7 +276,8 @@ def circle_overwrap(
         # Suppose that cpos.shape == (N, 2) and xy.shape == (2,)
         dist = jnp.linalg.norm(cpos - jnp.expand_dims(xy, axis=0), axis=-1)
         penetration = shaped.circle.radius + radius - dist
-        overwrap2cir = jnp.any(penetration >= 0)
+        has_overwrap = jnp.logical_and(stated.circle.is_active, penetration >= 0)
+        overwrap2cir = jnp.any(has_overwrap)
     else:
         overwrap2cir = jnp.array(False)
 
@@ -287,7 +288,6 @@ def circle_overwrap(
         # Suppose that cpos.shape == (N, 2) and xy.shape == (2,)
         pb = spos.inv_transform(jnp.expand_dims(xy, axis=0))
         p1, p2 = _length_to_points(shaped.segment.length)
-        p1, p2 = jnp.squeeze(p1, axis=1), jnp.squeeze(p2, axis=1)
         edge = p2 - p1
         s1 = jnp.expand_dims(_vmap_dot(pb - p1, edge), axis=1)
         s2 = jnp.expand_dims(_vmap_dot(p2 - pb, edge), axis=1)
@@ -296,7 +296,8 @@ def circle_overwrap(
         pa = jnp.where(in_segment, p1 + edge * s1 / ee, jnp.where(s1 < 0.0, p1, p2))
         dist = jnp.linalg.norm(pb - pa, axis=-1)
         penetration = radius - dist
-        overwrap2seg = jnp.any(penetration >= 0)
+        has_overwrap = jnp.logical_and(stated.segment.is_active, penetration >= 0)
+        overwrap2seg = jnp.any(has_overwrap)
     else:
         overwrap2seg = jnp.array(False)
 
diff --git a/src/emevo/environments/placement.py b/src/emevo/environments/placement.py
index fe99731c..dbae2308 100644
--- a/src/emevo/environments/placement.py
+++ b/src/emevo/environments/placement.py
@@ -44,7 +44,7 @@ def place_food(
 ) -> jax.Array:
     """Returns `[inf, inf]` if it fails"""
     keys = jax.random.split(key, n_trial)
-    loc_fn = jax.vmap(reprloc_fn, in_axes=(0, None), out_axes=(0, None))
+    loc_fn = jax.vmap(reprloc_fn, in_axes=(0, None))
     locations = loc_fn(keys, reprloc_state)
     return _place_common(
         coordinate,
diff --git a/src/emevo/environments/pymunk_envs/moderngl_vis.py b/src/emevo/environments/pymunk_envs/moderngl_vis.py
index 2c908b6b..28872857 100644
--- a/src/emevo/environments/pymunk_envs/moderngl_vis.py
+++ b/src/emevo/environments/pymunk_envs/moderngl_vis.py
@@ -4,7 +4,7 @@
 """
 from __future__ import annotations
 
-from typing import Any, ClassVar, Iterable
+from typing import Any, ClassVar, Protocol
 
 import moderngl as mgl
 import moderngl_window as mglw
@@ -14,6 +14,11 @@
 
 from emevo.environments.phyjax2d import Circle, Segment, Space, State, StateDict
 
+
+class HasStateD(Protocol):
+    stated: StateDict
+
+
 _CIRCLE_VERTEX_SHADER = """
 #version 330
 uniform mat4 proj;
@@ -253,14 +258,12 @@ def _collect_circles(
     state: State,
     circle_scaling: float,
 ) -> tuple[NDArray, NDArray, NDArray]:
-    points = state.p.xy
+    points = np.array(state.p.xy, dtype=np.float32)
     scales = circle.radius * circle_scaling
-    colors = circle.rgba
-    return (
-        np.array(points, dtype=np.float32),
-        np.array(scales, dtype=np.float32),
-        np.array(colors, dtype=np.float32) / 255.0,
-    )
+    colors = np.array(circle.rgba, dtype=np.float32) / 255.0
+    is_active = np.expand_dims(np.array(state.is_active), axis=1)
+    colors = np.where(is_active, colors, np.ones_like(colors))
+    return points, np.array(scales, dtype=np.float32), colors
 
 
 def _collect_static_lines(segment: Segment, state: State) -> NDArray:
@@ -341,7 +344,10 @@ def __init__(
         self._static_lines = SegmentVA(
             ctx=context,
             program=static_segment_program,
-            segments=_collect_static_lines(space.shaped.segment, stated.segment),
+            segments=_collect_static_lines(
+                space.shaped.segment,
+                stated.segment,
+            ),
         )
         # head_program = self._make_gl_program(
         #     vertex_shader=_LINE_VERTEX_SHADER,
@@ -430,7 +436,7 @@ def overlay(self, name: str, value: Any) -> Any:
 
     def render(self, stated: StateDict) -> None:
         circles = _collect_circles(
-            space.shaped.circle,
+            self._space.shaped.circle,
             stated.circle,
             self._circle_scaling,
         )
@@ -502,10 +508,10 @@ def get_image(self) -> NDArray:
     def overlay(self, name: str, value: Any) -> None:
         self._renderer.overlay(name, value)
 
-    def render(self, stated: StateDict) -> None:
+    def render(self, state: HasStateD) -> None:
         self._window.clear(1.0, 1.0, 1.0)
         self._window.use()
-        self._renderer.render(stated=stated)
+        self._renderer.render(stated=state.stated)
 
     def show(self) -> None:
         self._window.swap_buffers()
diff --git a/src/emevo/visualizer.py b/src/emevo/visualizer.py
index 12e356ef..a1c4274e 100644
--- a/src/emevo/visualizer.py
+++ b/src/emevo/visualizer.py
@@ -5,10 +5,10 @@
 
 from numpy.typing import NDArray
 
-ENV = TypeVar("ENV", contravariant=True)
+STATE = TypeVar("STATE", contravariant=True)
 
 
-class Visualizer(Protocol[ENV]):
+class Visualizer(Protocol[STATE]):
     def close(self) -> None:
         """Close this visualizer"""
         ...
@@ -16,7 +16,7 @@ def close(self) -> None:
     def get_image(self) -> NDArray:
         ...
 
-    def render(self, env: ENV) -> Any:
+    def render(self, state: STATE) -> Any:
         """Render image"""
         ...
 
@@ -29,8 +29,8 @@ def overlay(self, name: str, _value: Any) -> Any:
         raise ValueError(f"Unsupported overlay: {name}")
 
 
-class VisWrapper(Visualizer[ENV], Protocol):
-    unwrapped: Visualizer[ENV]
+class VisWrapper(Visualizer[STATE], Protocol):
+    unwrapped: Visualizer[STATE]
 
     def close(self) -> None:
         self.unwrapped.close()
@@ -38,8 +38,8 @@ def close(self) -> None:
     def get_image(self) -> NDArray:
         return self.unwrapped.get_image()
 
-    def render(self, env: ENV) -> Any:
-        return self.unwrapped.render(env)
+    def render(self, state: STATE) -> Any:
+        return self.unwrapped.render(state)
 
     def show(self) -> None:
         self.unwrapped.show()
@@ -48,10 +48,10 @@ def overlay(self, name: str, value: Any) -> Any:
         return self.unwrapped.overlay(name, value)
 
 
-class SaveVideoWrapper(VisWrapper[ENV]):
+class SaveVideoWrapper(VisWrapper[STATE]):
     def __init__(
         self,
-        visualizer: Visualizer[ENV],
+        visualizer: Visualizer[STATE],
         filename: PathLike,
         **kwargs,
     ) -> None:
diff --git a/tests/test_placement.py b/tests/test_placement.py
index 5fc2b7f7..f1dd459e 100644
--- a/tests/test_placement.py
+++ b/tests/test_placement.py
@@ -5,11 +5,14 @@
 
 from emevo.environments.circle_foraging import _make_space
 from emevo.environments.phyjax2d import Space, StateDict
-from emevo.environments.placement import place_agent
+from emevo.environments.placement import place_agent, place_food
+from emevo.environments.utils.food_repr import ReprLoc
 from emevo.environments.utils.locating import CircleCoordinate, InitLoc
 
 N_MAX_AGENTS = 20
 N_MAX_FOODS = 10
+AGENT_RADIUS = 10
+FOOD_RADIUS = 4
 
 
 @pytest.fixture
@@ -24,6 +27,8 @@ def get_space_and_more() -> tuple[Space, StateDict, CircleCoordinate]:
         coordinate,
         n_max_agents=N_MAX_AGENTS,
         n_max_foods=N_MAX_FOODS,
+        agent_radius=AGENT_RADIUS,
+        food_radius=FOOD_RADIUS,
     )
     stated = space.shaped.zeros_state().replace(segment=seg_state)
     return space, stated, coordinate
@@ -33,18 +38,66 @@ def test_place_agents(key) -> None:
     n = N_MAX_AGENTS // 2
     keys = jax.random.split(key, n)
     space, stated, coordinate = get_space_and_more()
-    initloc_fn = InitLoc.GAUSSIAN((100.0, 100.0), (10.0, 10.0))
-
+    initloc_fn = InitLoc.UNIFORM(CircleCoordinate((100.0, 100.0), 95.0))
+    assert stated.circle is not None
     for i, key in enumerate(keys):
         xy = place_agent(
             n_trial=10,
-            agent_radius=6.0,
+            agent_radius=AGENT_RADIUS,
             coordinate=coordinate,
             initloc_fn=initloc_fn,
             key=key,
             shaped=space.shaped,
             stated=stated,
         )
-        assert jnp.all(xy < jnp.inf)
-        circle_xy = circle_xy.at[i].set(xy)
-        circle = circle.replace(p=circle.p.replace(xy=circle_xy))  # type: ignore
+        assert jnp.all(xy < jnp.inf), stated.circle.p.xy
+        stated = stated.nested_replace("circle.p.xy", stated.circle.p.xy.at[i].set(xy))
+
+    is_active = jnp.concatenate(
+        (
+            jnp.ones(n, dtype=bool),
+            jnp.zeros(N_MAX_AGENTS + N_MAX_FOODS - n, dtype=bool),
+        )
+    )
+    stated = stated.nested_replace("circle.is_active", is_active)
+
+    # test no overwrap each other
+    contact_data = space.check_contacts(stated)
+    assert jnp.all(contact_data.contact.penetration <= 0.0)
+
+
+def test_place_foods(key) -> None:
+    n = N_MAX_FOODS // 2
+    keys = jax.random.split(key, n)
+    space, stated, coordinate = get_space_and_more()
+    reprloc_fn, reprloc_state = ReprLoc.UNIFORM(CircleCoordinate((100.0, 100.0), 95.0))
+    assert stated.circle is not None
+    for i, key in enumerate(keys):
+        xy = place_food(
+            n_trial=10,
+            food_radius=FOOD_RADIUS,
+            coordinate=coordinate,
+            reprloc_fn=reprloc_fn,
+            reprloc_state=reprloc_state,
+            key=key,
+            shaped=space.shaped,
+            stated=stated,
+        )
+        assert jnp.all(xy < jnp.inf), stated.circle.p.xy
+        stated = stated.nested_replace(
+            "circle.p.xy",
+            stated.circle.p.xy.at[i + N_MAX_AGENTS].set(xy),
+        )
+
+    is_active = jnp.concatenate(
+        (
+            jnp.zeros(N_MAX_AGENTS, dtype=bool),
+            jnp.ones(n, dtype=bool),
+            jnp.zeros(N_MAX_FOODS - n, dtype=bool),
+        )
+    )
+    stated = stated.nested_replace("circle.is_active", is_active)
+
+    # test no overwrap each other
+    contact_data = space.check_contacts(stated)
+    assert jnp.all(contact_data.contact.penetration <= 0.0)

From ac35aee37807ee8deac1eb823a8d94e13bb6bf9c Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 19 Oct 2023 17:29:45 +0900
Subject: [PATCH 029/337] activate/deactivate

---
 src/emevo/env.py                          |  7 +++-
 src/emevo/environments/circle_foraging.py | 42 ++++++++++++++++++++---
 2 files changed, 44 insertions(+), 5 deletions(-)

diff --git a/src/emevo/env.py b/src/emevo/env.py
index 56eaecb4..214d4728 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -67,7 +67,12 @@ def step(self, state: STATE, action: ArrayLike) -> tuple[STATE, TimeStep]:
         pass
 
     @abc.abstractmethod
-    def activate(self, state: STATE, index: Index) -> STATE:
+    def activate(
+        self,
+        key: chex.PRNGKey,
+        state: STATE,
+        index: Index,
+    ) -> tuple[STATE, bool]:
         """Mark an agent or some agents active."""
         pass
 
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 5914fa21..d0deb20a 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -8,7 +8,7 @@
 from jax.typing import ArrayLike
 
 from emevo.env import Env, Profile, Visualizer
-from emevo.environments.phyjax2d import Position, Space, State, StateDict
+from emevo.environments.phyjax2d import Position, Space, State, StateDict, Velocity
 from emevo.environments.phyjax2d_utils import (
     SpaceBuilder,
     make_approx_circle,
@@ -203,6 +203,8 @@ def __init__(
         self._agent_indices = jnp.arange(n_max_agents)
         self._food_indices = jnp.arange(n_max_foods)
         self._n_physics_steps = n_physics_steps
+        # Placeholder
+        self._invisible_xy = jnp.array([-100.0, -100.0], dtype=jnp.float32)
 
     @staticmethod
     def _make_food_num_fn(
@@ -276,11 +278,43 @@ def set_agent_loc_fn(self, agent_loc_fn: str | tuple | InitLocFn) -> None:
     def step(self, state: CFState, action: ArrayLike):
         pass
 
-    def activate(self, state: CFState, index: Index) -> CFState:
-        pass
+    def activate(
+        self,
+        key: chex.PRNGKey,
+        state: CFState,
+        index: Index,
+    ) -> tuple[CFState, bool]:
+        xy = place_agent(
+            n_trial=self._max_place_attempts,
+            agent_radius=self._agent_radius,
+            coordinate=self._coordinate,
+            initloc_fn=self._agent_loc_fn,
+            key=key,
+            shaped=self._space.shaped,
+            stated=state.physics,
+        )
+
+        def success() -> CFState:
+            circle_xy = state.physics.circle.p.xy.at[index].set(xy)
+            circle_angle = state.physics.circle.p.angle.at[index].set(0.0)
+            p = Position(angle=circle_angle, xy=circle_xy)
+            is_active = state.physics.circle.is_active.at[index].set(True)
+            circle = state.physics.circle.replace(p=p, is_active=is_active)
+            physics = state.physics.replace(circle=circle)
+            return state.replace(physics=physics), True
+
+        return jnp.cond(jnp.all(xy < jnp.inf), success, lambda: state)
 
     def deactivate(self, state: CFState, index: Index) -> CFState:
-        pass
+        p_xy = state.physics.circle.p.xy.at[index].set(self._invisible_xy)
+        p = Position(xy=p_xy)
+        v_xy = state.physics.circle.v.xy.at[index].set(jnp.zeros(2))
+        v_angle = state.physics.circle.v.xy.at[index].set(jnp.zeros(1))
+        v = Velocity(angle=v_angle, xy=v_xy)
+        is_active = state.physics.circle.is_active.at[index].set(False)
+        circle = state.physics.circle.replace(p=p, v=v, is_active=is_active)
+        physics = state.physics.replace(circle=circle)
+        return state.replace(physics=physics)
 
     def is_extinct(self, state: CFState) -> bool:
         pass

From a0f30ce481158b3cf0a710605dd68f31fb71efe7 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 20 Oct 2023 17:21:17 +0900
Subject: [PATCH 030/337] Debug activate/deactivate

---
 smoke-tests/circle_loop.py                | 24 +++++--
 src/emevo/env.py                          | 62 +++++++++++++---
 src/emevo/environments/circle_foraging.py | 87 ++++++++++++++++-------
 src/emevo/environments/placement.py       | 14 ++--
 4 files changed, 139 insertions(+), 48 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index 509fdf89..385c1caa 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -4,14 +4,13 @@
 import enum
 from typing import Any, Optional, Tuple
 
+import jax
 import numpy as np
 import typer
 from numpy.random import PCG64
 from tqdm import tqdm
-import jax
-from emevo import make
-
 
+from emevo import make
 
 
 class FoodNum(str, enum.Enum):
@@ -52,6 +51,8 @@ def main(
     env = make(
         "CircleForaging-v0",
         env_shape=env_shape,
+        n_max_agents=20,
+        n_initial_agents=6,
         **env_kwargs,
     )
     state = env.reset(jax.random.PRNGKey(43))
@@ -59,16 +60,31 @@ def main(
     if render is not None:
         visualizer = env.visualizer(state)
 
+    activate_index = 5
+
     for i in tqdm(range(steps)):
         # actions = {body: body.act_space.sample(gen) for body in bodies}
         # Samples for adding constant force for debugging
         # actions = {body: np.array([0.0, -1.0]) for body in bodies}
         # _ = env.step(actions)  # type: ignore
+        if i % 1000 == 0:
+            if 10 <= activate_index:
+                state, success = env.deactivate(state, activate_index)
+                if not success:
+                    print(f"Failed to deactivate agent! {activate_index}")
+                else:
+                    activate_index -= 1
+            else:
+                state, success = env.activate(0, state)
+                if not success:
+                    print("Failed to activate agent!")
+                else:
+                    activate_index += 1
+
         if visualizer is not None:
             visualizer.render(state)
             visualizer.show()
 
 
-
 if __name__ == "__main__":
     typer.run(main)
diff --git a/src/emevo/env.py b/src/emevo/env.py
index 214d4728..ed8dd0b7 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -1,6 +1,4 @@
-"""
-Abstract environment API inspired by jumanji
-"""
+"""Abstract environment API"""
 from __future__ import annotations
 
 import abc
@@ -8,11 +6,14 @@
 
 import chex
 import jax
+import jax.numpy as jnp
 from jax.typing import ArrayLike
 
 from emevo.types import Index, PyTree
 from emevo.visualizer import Visualizer
 
+Self = Any
+
 
 @chex.dataclass
 class Profile:
@@ -20,13 +21,57 @@ class Profile:
 
     birthtime: jax.Array
     generation: jax.Array
-    index: jax.Array
+    unique_id: jax.Array
+
+    def activate(
+        self,
+        index: Index,
+        parent_gen: jax.Array,
+        uid: jax.Array,
+        step: jax.Array,
+    ) -> Self:
+        unique_id = self.unique_id.at[index].set(uid)
+        birthtime = self.birthtime.at[index].set(step)
+        generation = self.generation.at[index].set(parent_gen + 1)
+        return self.replace(
+            birthtime=birthtime,
+            generation=generation,
+            unique_id=unique_id,
+        )
+
+    def deactivate(self, index: Index) -> Self:
+        unique_id = self.unique_id.at[index].set(-1)
+        birthtime = self.birthtime.at[index].set(-1)
+        generation = self.generation.at[index].set(-1)
+        return self.replace(
+            birthtime=birthtime,
+            generation=generation,
+            unique_id=unique_id,
+        )
+
+    def is_active(self) -> jax.Array:
+        return 0 <= self.unique_id
+
+
+def init_profile(n: int, max_n: int) -> Profile:
+    minus_1 = jnp.ones(max_n - n, dtype=jnp.int32) * -1
+    birthtime = jnp.concatenate((jnp.zeros(n, dtype=jnp.int32), minus_1))
+    generation = jnp.concatenate((jnp.zeros(n, dtype=jnp.int32), minus_1))
+    unique_id = jnp.concatenate((jnp.arange(n, dtype=jnp.int32), minus_1))
+    return Profile(
+        birthtime=birthtime,
+        generation=generation,
+        unique_id=unique_id,
+    )
 
 
 class StateProtocol(Protocol):
     """Each state should have PRNG key"""
 
     key: chex.PRNGKey
+    step: jax.Array
+    profile: Profile
+    n_born_agents: jax.Array
 
 
 STATE = TypeVar("STATE", bound="StateProtocol")
@@ -53,11 +98,6 @@ def reset(self, key: chex.PRNGKey) -> STATE:
         """Initialize environmental state."""
         pass
 
-    @abc.abstractmethod
-    def profile(self) -> Profile:
-        """Returns profile of all 'alive' agents in the environment"""
-        pass
-
     @abc.abstractmethod
     def step(self, state: STATE, action: ArrayLike) -> tuple[STATE, TimeStep]:
         """
@@ -70,14 +110,14 @@ def step(self, state: STATE, action: ArrayLike) -> tuple[STATE, TimeStep]:
     def activate(
         self,
         key: chex.PRNGKey,
+        parent_gen: jax.Array,
         state: STATE,
-        index: Index,
     ) -> tuple[STATE, bool]:
         """Mark an agent or some agents active."""
         pass
 
     @abc.abstractmethod
-    def deactivate(self, state: STATE, index: Index) -> STATE:
+    def deactivate(self, state: STATE) -> tuple[STATE, bool]:
         """
         Deactivate an agent or some agents. The shape of observations should remain the
         same so that `Env.step` is compiled onle once. So, to represent that an agent is
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index d0deb20a..c3141ed6 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -7,7 +7,7 @@
 import numpy as np
 from jax.typing import ArrayLike
 
-from emevo.env import Env, Profile, Visualizer
+from emevo.env import Env, Profile, Visualizer, init_profile
 from emevo.environments.phyjax2d import Position, Space, State, StateDict, Velocity
 from emevo.environments.phyjax2d_utils import (
     SpaceBuilder,
@@ -60,6 +60,10 @@ class CFState:
     physics: StateDict
     food_num: FoodNumState
     repr_loc: ReprLocState
+    key: chex.PRNGKey
+    step: jax.Array
+    profile: Profile
+    n_born_agents: jax.Array
 
     @property
     def stated(self) -> StateDict:
@@ -278,55 +282,86 @@ def set_agent_loc_fn(self, agent_loc_fn: str | tuple | InitLocFn) -> None:
     def step(self, state: CFState, action: ArrayLike):
         pass
 
-    def activate(
-        self,
-        key: chex.PRNGKey,
-        state: CFState,
-        index: Index,
-    ) -> tuple[CFState, bool]:
+    def activate(self, parent_gen: jax.Array, state: CFState) -> tuple[CFState, bool]:
+        key, activate_key = jax.random.split(state.key)
+        (index,) = jnp.nonzero(
+            jnp.logical_not(state.profile.is_active()),
+            size=1,
+            fill_value=-1,
+        )
+        index = index[0]
         xy = place_agent(
             n_trial=self._max_place_attempts,
             agent_radius=self._agent_radius,
             coordinate=self._coordinate,
             initloc_fn=self._agent_loc_fn,
-            key=key,
+            key=activate_key,
             shaped=self._space.shaped,
             stated=state.physics,
         )
+        ok = jnp.logical_and(index >= 0, jnp.all(xy < jnp.inf))
 
-        def success() -> CFState:
+        def success() -> tuple[CFState, bool]:
             circle_xy = state.physics.circle.p.xy.at[index].set(xy)
             circle_angle = state.physics.circle.p.angle.at[index].set(0.0)
             p = Position(angle=circle_angle, xy=circle_xy)
             is_active = state.physics.circle.is_active.at[index].set(True)
             circle = state.physics.circle.replace(p=p, is_active=is_active)
             physics = state.physics.replace(circle=circle)
-            return state.replace(physics=physics), True
+            profile = state.profile.activate(
+                index,
+                parent_gen,
+                state.n_born_agents,
+                state.step,
+            )
+            new_state = state.replace(
+                physics=physics,
+                profile=profile,
+                n_born_agents=state.n_born_agents + 1,
+                key=key,
+            )
+            return new_state, True
 
-        return jnp.cond(jnp.all(xy < jnp.inf), success, lambda: state)
+        def failure() -> tuple[CFState, bool]:
+            return state.replace(key=key), False
 
-    def deactivate(self, state: CFState, index: Index) -> CFState:
-        p_xy = state.physics.circle.p.xy.at[index].set(self._invisible_xy)
-        p = Position(xy=p_xy)
-        v_xy = state.physics.circle.v.xy.at[index].set(jnp.zeros(2))
-        v_angle = state.physics.circle.v.xy.at[index].set(jnp.zeros(1))
-        v = Velocity(angle=v_angle, xy=v_xy)
-        is_active = state.physics.circle.is_active.at[index].set(False)
-        circle = state.physics.circle.replace(p=p, v=v, is_active=is_active)
-        physics = state.physics.replace(circle=circle)
-        return state.replace(physics=physics)
+        return jax.lax.cond(ok, success, failure)
 
-    def is_extinct(self, state: CFState) -> bool:
-        pass
+    def deactivate(self, state: CFState, index: Index) -> tuple[CFState, bool]:
+        ok = state.profile.is_active()[index]
+
+        def success() -> tuple[CFState, bool]:
+            p_xy = state.physics.circle.p.xy.at[index].set(self._invisible_xy)
+            p = state.physics.circle.p.replace(xy=p_xy)
+            v_xy = state.physics.circle.v.xy.at[index].set(jnp.zeros(2))
+            v_angle = state.physics.circle.v.angle.at[index].set(0)
+            v = Velocity(angle=v_angle, xy=v_xy)
+            is_active = state.physics.circle.is_active.at[index].set(False)
+            circle = state.physics.circle.replace(p=p, v=v, is_active=is_active)
+            physics = state.physics.replace(circle=circle)
+            profile = state.profile.deactivate(index)
+            return state.replace(physics=physics, profile=profile), True
 
-    def profile(self) -> Profile:
+        return jax.lax.cond(ok, success, lambda: (state, False))
+
+    def is_extinct(self, state: CFState) -> bool:
         pass
 
     def reset(self, key: chex.PRNGKey) -> CFState:
-        stated = self._initialize_physics_state(key)
+        state_key, init_key = jax.random.split(key)
+        stated = self._initialize_physics_state(init_key)
         repr_loc = self._initial_foodloc_state
         food_num = self._initial_foodnum_state
-        return CFState(physics=stated, repr_loc=repr_loc, food_num=food_num)
+        return CFState(
+            physics=stated,
+            repr_loc=repr_loc,
+            food_num=food_num,
+            # Protocols
+            key=state_key,
+            step=jnp.array(0, dtype=jnp.int32),
+            profile=init_profile(self._n_initial_agents, self._n_max_agents),
+            n_born_agents=jnp.array(self._n_initial_agents, dtype=jnp.int32),
+        )
 
     def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
         stated = self._space.shaped.zeros_state()
diff --git a/src/emevo/environments/placement.py b/src/emevo/environments/placement.py
index dbae2308..855ba27d 100644
--- a/src/emevo/environments/placement.py
+++ b/src/emevo/environments/placement.py
@@ -9,7 +9,6 @@
 from emevo.environments.utils.food_repr import ReprLocFn, ReprLocState
 from emevo.environments.utils.locating import Coordinate, InitLocFn
 
-_inf_xy = jnp.array([jnp.inf, jnp.inf])
 _vmap_co = jax.vmap(circle_overwrap, in_axes=(None, None, 0, 0))
 
 
@@ -24,12 +23,13 @@ def _place_common(
         jax.vmap(coordinate.contains_circle)(locations, radius),
         jnp.logical_not(_vmap_co(shaped, stated, locations, radius)),
     )
-
-    def step_fun(state: jax.Array, xi: tuple[jax.Array, jax.Array]):
-        is_ok, loc = xi
-        return jax.lax.select(is_ok, loc, state), None
-
-    return jax.lax.scan(step_fun, _inf_xy, (ok, locations))[0]
+    (ok_idx,) = jnp.nonzero(ok, size=1, fill_value=-1)
+    ok_idx = ok_idx[0]
+    return jax.lax.cond(
+        ok_idx < 0,
+        lambda: jnp.ones(2) * jnp.inf,
+        lambda: locations[ok_idx],
+    )
 
 
 def place_food(

From 93a6822e4a738f4a5198e23baee27e6f7d0beb01 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 20 Oct 2023 17:35:59 +0900
Subject: [PATCH 031/337] Make API consistent

---
 src/emevo/env.py                          | 9 ++-------
 src/emevo/environments/circle_foraging.py | 2 +-
 2 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/src/emevo/env.py b/src/emevo/env.py
index ed8dd0b7..f0a0eddd 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -107,17 +107,12 @@ def step(self, state: STATE, action: ArrayLike) -> tuple[STATE, TimeStep]:
         pass
 
     @abc.abstractmethod
-    def activate(
-        self,
-        key: chex.PRNGKey,
-        parent_gen: jax.Array,
-        state: STATE,
-    ) -> tuple[STATE, bool]:
+    def activate(self, state: STATE, parent_gen: int | jax.Array) -> tuple[STATE, bool]:
         """Mark an agent or some agents active."""
         pass
 
     @abc.abstractmethod
-    def deactivate(self, state: STATE) -> tuple[STATE, bool]:
+    def deactivate(self, state: STATE, index: Index) -> tuple[STATE, bool]:
         """
         Deactivate an agent or some agents. The shape of observations should remain the
         same so that `Env.step` is compiled onle once. So, to represent that an agent is
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index c3141ed6..c59b92c7 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -282,7 +282,7 @@ def set_agent_loc_fn(self, agent_loc_fn: str | tuple | InitLocFn) -> None:
     def step(self, state: CFState, action: ArrayLike):
         pass
 
-    def activate(self, parent_gen: jax.Array, state: CFState) -> tuple[CFState, bool]:
+    def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:
         key, activate_key = jax.random.split(state.key)
         (index,) = jnp.nonzero(
             jnp.logical_not(state.profile.is_active()),

From 9ff1899c414eb12b29fe06ef2962995edb5baad3 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 20 Oct 2023 18:10:06 +0900
Subject: [PATCH 032/337] is_extinct

---
 src/emevo/env.py                          | 3 +++
 src/emevo/environments/circle_foraging.py | 8 ++++----
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/emevo/env.py b/src/emevo/env.py
index f0a0eddd..ebdfa548 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -73,6 +73,9 @@ class StateProtocol(Protocol):
     profile: Profile
     n_born_agents: jax.Array
 
+    def is_extinct(self) -> bool:
+        ...
+
 
 STATE = TypeVar("STATE", bound="StateProtocol")
 
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index c59b92c7..03216c1a 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -69,6 +69,9 @@ class CFState:
     def stated(self) -> StateDict:
         return self.physics
 
+    def is_extinct(self) -> bool:
+        return jnp.logical_not(jnp.any(self.profile.is_active()))
+
 
 def _get_num_or_loc_fn(
     arg: str | tuple | list,
@@ -279,7 +282,7 @@ def set_food_loc_fn(self, food_loc_fn: str | tuple | ReprLocFn) -> None:
     def set_agent_loc_fn(self, agent_loc_fn: str | tuple | InitLocFn) -> None:
         self._agent_loc_fn = self._make_agent_loc_fn(agent_loc_fn)
 
-    def step(self, state: CFState, action: ArrayLike):
+    def step(self, state: CFState, action: ArrayLike) -> CFState:
         pass
 
     def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:
@@ -344,9 +347,6 @@ def success() -> tuple[CFState, bool]:
 
         return jax.lax.cond(ok, success, lambda: (state, False))
 
-    def is_extinct(self, state: CFState) -> bool:
-        pass
-
     def reset(self, key: chex.PRNGKey) -> CFState:
         state_key, init_key = jax.random.split(key)
         stated = self._initialize_physics_state(init_key)

From 9883f041f81b3a37f0c4b4aa6a586de8fefe3dff Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 23 Oct 2023 18:03:38 +0900
Subject: [PATCH 033/337] Implement step

---
 smoke-tests/circle_loop.py                |  6 +-
 src/emevo/env.py                          |  9 ++-
 src/emevo/environments/circle_foraging.py | 68 ++++++++++++++++++-----
 src/emevo/environments/phyjax2d.py        | 55 +++++++++++-------
 src/emevo/environments/phyjax2d_utils.py  |  9 ++-
 src/emevo/spaces.py                       |  9 +--
 src/emevo/vec2d.py                        |  2 +-
 7 files changed, 109 insertions(+), 49 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index 385c1caa..dd31b257 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -67,6 +67,10 @@ def main(
         # Samples for adding constant force for debugging
         # actions = {body: np.array([0.0, -1.0]) for body in bodies}
         # _ = env.step(actions)  # type: ignore
+        key, act_key = jax.random.split(state.key)
+        state = state.replace(key=key)
+        act = env.act_space.sample(act_key)
+        state = env.step(state, act)
         if i % 1000 == 0:
             if 10 <= activate_index:
                 state, success = env.deactivate(state, activate_index)
@@ -75,7 +79,7 @@ def main(
                 else:
                     activate_index -= 1
             else:
-                state, success = env.activate(0, state)
+                state, success = env.activate(state, 0)
                 if not success:
                     print("Failed to activate agent!")
                 else:
diff --git a/src/emevo/env.py b/src/emevo/env.py
index ebdfa548..22e67cb0 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -9,6 +9,7 @@
 import jax.numpy as jnp
 from jax.typing import ArrayLike
 
+from emevo.spaces import Space
 from emevo.types import Index, PyTree
 from emevo.visualizer import Visualizer
 
@@ -92,6 +93,9 @@ class TimeStep:
 class Env(abc.ABC, Generic[STATE, OBS]):
     """Abstract API for emevo environments"""
 
+    act_space: Space
+    obs_space: Space
+
     def __init__(self, *args, **kwargs) -> None:
         # To supress PyRight errors in registry
         pass
@@ -124,11 +128,6 @@ def deactivate(self, state: STATE, index: Index) -> tuple[STATE, bool]:
         """
         pass
 
-    @abc.abstractmethod
-    def is_extinct(self, state: STATE) -> bool:
-        """Return if agents are extinct"""
-        pass
-
     @abc.abstractmethod
     def visualizer(self, headless: bool = False, **kwargs) -> Visualizer:
         """Create a visualizer for the environment"""
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 03216c1a..123af60e 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -8,7 +8,10 @@
 from jax.typing import ArrayLike
 
 from emevo.env import Env, Profile, Visualizer, init_profile
-from emevo.environments.phyjax2d import Position, Space, State, StateDict, Velocity
+from emevo.environments.phyjax2d import Position
+from emevo.environments.phyjax2d import Space as Physics
+from emevo.environments.phyjax2d import State, StateDict, Velocity, VelocitySolver
+from emevo.environments.phyjax2d import step as physics_step
 from emevo.environments.phyjax2d_utils import (
     SpaceBuilder,
     make_approx_circle,
@@ -29,7 +32,13 @@
     InitLocFn,
     SquareCoordinate,
 )
+from emevo.spaces import BoxSpace, NamedTupleSpace
 from emevo.types import Index
+from emevo.vec2d import Vec2d
+
+MAX_ANGULAR_VELOCITY: float = float(np.pi)
+MAX_VELOCITY: float = 10.0
+MAX_FORCE: float = 1.0
 
 
 class CFObs(NamedTuple):
@@ -58,6 +67,7 @@ def __array__(self) -> jax.Array:
 @chex.dataclass
 class CFState:
     physics: StateDict
+    solver: VelocitySolver
     food_num: FoodNumState
     repr_loc: ReprLocState
     key: chex.PRNGKey
@@ -87,7 +97,7 @@ def _get_num_or_loc_fn(
         raise ValueError(f"Invalid value in _get_num_or_loc_fn {arg}")
 
 
-def _make_space(
+def _make_physics(
     dt: float,
     coordinate: CircleCoordinate | SquareCoordinate,
     linear_damping: float = 0.9,
@@ -98,7 +108,7 @@ def _make_space(
     n_max_foods: int = 20,
     agent_radius: float = 10.0,
     food_radius: float = 4.0,
-) -> tuple[Space, State]:
+) -> tuple[Physics, State]:
     builder = SpaceBuilder(
         gravity=(0.0, 0.0),  # No gravity
         dt=dt,
@@ -106,6 +116,8 @@ def _make_space(
         angular_damping=angular_damping,
         n_velocity_iter=n_velocity_iter,
         n_position_iter=n_position_iter,
+        max_velocity=MAX_VELOCITY,
+        max_angular_velocity=MAX_ANGULAR_VELOCITY,
     )
     # Set walls
     if isinstance(coordinate, CircleCoordinate):
@@ -140,7 +152,7 @@ def __init__(
         self,
         n_initial_agents: int = 6,
         n_max_agents: int = 100,
-        n_max_foods: int = 100,
+        n_max_foods: int = 40,
         food_num_fn: ReprNumFn | str | tuple[str, ...] = "constant",
         food_loc_fn: ReprLocFn | str | tuple[str, ...] = "gaussian",
         agent_loc_fn: InitLocFn | str | tuple[str, ...] = "uniform",
@@ -151,11 +163,10 @@ def __init__(
         obstacles: list[tuple[float, float, float, float]] | None = None,
         n_agent_sensors: int = 8,
         sensor_length: float = 10.0,
-        sensor_range: tuple[float, float] = (-180.0, 180.0),
+        sensor_range: tuple[float, float] = (-120.0, 120.0),
         agent_radius: float = 12.0,
         food_radius: float = 4.0,
         foodloc_interval: int = 1000,
-        max_abs_impulse: float = 0.2,
         dt: float = 0.05,
         linear_damping: float = 0.9,
         angular_damping: float = 0.8,
@@ -195,7 +206,7 @@ def __init__(
         self._n_max_foods = n_max_foods
         self._max_place_attempts = max_place_attempts
         # Physics
-        self._space, self._segment_state = _make_space(
+        self._physics, self._segment_state = _make_physics(
             dt=dt,
             coordinate=self._coordinate,
             linear_damping=linear_damping,
@@ -210,8 +221,26 @@ def __init__(
         self._agent_indices = jnp.arange(n_max_agents)
         self._food_indices = jnp.arange(n_max_foods)
         self._n_physics_steps = n_physics_steps
-        # Placeholder
+        # Spaces
+        N = self._n_max_agents
+        self.act_space = BoxSpace(low=0.0, high=MAX_FORCE, shape=(N, 2))
+        self.obs_space = NamedTupleSpace(
+            CFObs,
+            sensor=BoxSpace(low=0.0, high=1.0, shape=(N, n_agent_sensors, 3)),
+            collision=BoxSpace(low=0.0, high=1.0, shape=(N, 3)),
+            velocity=BoxSpace(low=-MAX_VELOCITY, high=MAX_VELOCITY, shape=(N, 2)),
+            angle=BoxSpace(low=-2 * np.pi, high=2 * np.pi, shape=(N,)),
+            angular_velocity=BoxSpace(low=-np.pi / 10, high=np.pi / 10, shape=(N,)),
+            energy=BoxSpace(low=0.0, high=50.0, shape=(N,)),
+        )
+        # Some cached constants
         self._invisible_xy = jnp.array([-100.0, -100.0], dtype=jnp.float32)
+        act_p1 = Vec2d(0, agent_radius).rotated(np.pi * 0.75)
+        act_p2 = Vec2d(0, agent_radius).rotated(-np.pi * 0.75)
+        N = self._n_max_agents + self._n_max_foods
+        self._act_p1 = jnp.tile(jnp.array(act_p1), (N, 1))
+        self._act_p2 = jnp.tile(jnp.array(act_p2), (N, 1))
+        self._act_food = jnp.zeros((self._n_max_foods, 2))
 
     @staticmethod
     def _make_food_num_fn(
@@ -283,7 +312,17 @@ def set_agent_loc_fn(self, agent_loc_fn: str | tuple | InitLocFn) -> None:
         self._agent_loc_fn = self._make_agent_loc_fn(agent_loc_fn)
 
     def step(self, state: CFState, action: ArrayLike) -> CFState:
-        pass
+        act = self.act_space.clip(jnp.array(action))
+        act = jnp.concatenate((act, self._act_food), axis=0)
+        f1, f2 = act[:, 0], act[:, 1]
+        f1 = jnp.stack((jnp.zeros_like(f1), f1), axis=1)
+        f2 = jnp.stack((jnp.zeros_like(f2), f2), axis=1)
+        circle = state.physics.circle
+        circle = circle.apply_force_local(self._act_p1, f1)
+        circle = circle.apply_force_local(self._act_p2, f2)
+        stated = state.physics.replace(circle=circle)
+        stated, solver = physics_step(self._physics, stated, state.solver)
+        return state.replace(physics=stated)
 
     def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:
         key, activate_key = jax.random.split(state.key)
@@ -299,7 +338,7 @@ def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool
             coordinate=self._coordinate,
             initloc_fn=self._agent_loc_fn,
             key=activate_key,
-            shaped=self._space.shaped,
+            shaped=self._physics.shaped,
             stated=state.physics,
         )
         ok = jnp.logical_and(index >= 0, jnp.all(xy < jnp.inf))
@@ -354,6 +393,7 @@ def reset(self, key: chex.PRNGKey) -> CFState:
         food_num = self._initial_foodnum_state
         return CFState(
             physics=stated,
+            solver=self._physics.init_solver(),
             repr_loc=repr_loc,
             food_num=food_num,
             # Protocols
@@ -364,7 +404,7 @@ def reset(self, key: chex.PRNGKey) -> CFState:
         )
 
     def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
-        stated = self._space.shaped.zeros_state()
+        stated = self._physics.shaped.zeros_state()
         assert stated.circle is not None
 
         is_active = jnp.concatenate(
@@ -390,7 +430,7 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
                 coordinate=self._coordinate,
                 initloc_fn=self._agent_loc_fn,
                 key=key,
-                shaped=self._space.shaped,
+                shaped=self._physics.shaped,
                 stated=stated,
             )
             if jnp.all(xy < jnp.inf):
@@ -414,7 +454,7 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
                 reprloc_fn=self._food_loc_fn,  # type: ignore
                 reprloc_state=foodloc_state,
                 key=key,
-                shaped=self._space.shaped,
+                shaped=self._physics.shaped,
                 stated=stated,
             )
             if jnp.all(xy < jnp.inf):
@@ -443,7 +483,7 @@ def visualizer(
         return moderngl_vis.MglVisualizer(
             x_range=self._x_range,
             y_range=self._y_range,
-            space=self._space,
+            space=self._physics,
             stated=state.physics,
             figsize=figsize,
             backend=mgl_backend,
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 193703ba..ad95ecc8 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -239,6 +239,18 @@ def zeros(n: int) -> Self:
             is_active=jnp.ones(n),
         )
 
+    def apply_force_global(self, point: jax.Array, force: jax.Array) -> Self:
+        chex.assert_equal_shape((self.f.xy, force))
+        xy = self.f.xy + force
+        angle = self.f.angle + jnp.cross(point - self.p.xy, force)
+        f = self.f.replace(xy=xy, angle=angle)
+        return self.replace(f=f)
+
+    def apply_force_local(self, point: jax.Array, force: jax.Array) -> Self:
+        chex.assert_equal_shape((self.p.xy, point))
+        point = self.p.transform(point)
+        return self.apply_force_global(point, force)
+
 
 @chex.dataclass
 class Contact(PyTreeOps):
@@ -309,16 +321,6 @@ def update(self, new_contact: jax.Array) -> Self:
         return self.replace(pn=pn, pt=pt, contact=new_contact)
 
 
-def init_solver(n: int) -> VelocitySolver:
-    return VelocitySolver(
-        v1=Velocity.zeros(n),
-        v2=Velocity.zeros(n),
-        pn=jnp.zeros(n),
-        pt=jnp.zeros(n),
-        contact=jnp.zeros(n, dtype=bool),
-    )
-
-
 def _vmap_dot(xy1: jax.Array, xy2: jax.Array) -> jax.Array:
     """Dot product between nested vectors"""
     chex.assert_equal_shape((xy1, xy2))
@@ -598,6 +600,8 @@ class Space:
     max_linear_correction: float = 0.2
     allowed_penetration: float = 0.005
     bounce_threshold: float = 1.0
+    max_velocity: float = 100.0
+    max_angular_velocity: float = 100.0
 
     def check_contacts(self, stated: StateDict) -> ContactWithMetadata:
         contacts = []
@@ -620,13 +624,6 @@ def check_contacts(self, stated: StateDict) -> ContactWithMetadata:
                     outer_index=outer_index + offset1,
                     inner_index=inner_index + offset2,
                 )
-                if jnp.any(contact.penetration >= 0.0):
-                    total_loop = 0
-                    for i in range(len1):
-                        for j in range(len2):
-                            if total_loop == 394:
-                                print(stated[n1].p.get_slice(i), stated[n2].p.get_slice(j))
-                            total_loop += 1
                 contacts.append(contact_with_meta)
         return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *contacts)
 
@@ -641,6 +638,16 @@ def n_possible_contacts(self) -> int:
                     n += len1 * len2
         return n
 
+    def init_solver(self) -> VelocitySolver:
+        n = self.n_possible_contacts()
+        return VelocitySolver(
+            v1=Velocity.zeros(n),
+            v2=Velocity.zeros(n),
+            pn=jnp.zeros(n),
+            pt=jnp.zeros(n),
+            contact=jnp.zeros(n, dtype=bool),
+        )
+
 
 def update_velocity(space: Space, shape: Shape, state: State) -> State:
     # Expand (N, ) to (N, 1) because xy has a shape (N, 2)
@@ -652,6 +659,12 @@ def update_velocity(space: Space, shape: Shape, state: State) -> State:
     )
     v_xy = state.v.xy + (gravity + state.f.xy * invm) * space.dt
     v_ang = state.v.angle + state.f.angle * shape.inv_moment() * space.dt
+    v_xy = jnp.clip(state.v.xy, a_max=space.max_velocity, a_min=-space.max_velocity)
+    v_ang = jnp.clip(
+        state.v.angle,
+        a_max=space.max_angular_velocity,
+        a_min=-space.max_angular_velocity,
+    )
     # Damping: dv/dt + vc = 0 -> v(t) = v0 * exp(-tc)
     # v(t + dt) = v0 * exp(-tc - dtc) = v0 * exp(-tc) * exp(-dtc) = v(t)exp(-dtc)
     # Thus, linear/angular damping factors are actually exp(-dtc)
@@ -960,7 +973,11 @@ def dont_solve_constraints(
     return v, p, solver
 
 
-def step(space: Space, stated: StateDict, solver: VelocitySolver) -> StateDict:
+def step(
+    space: Space,
+    stated: StateDict,
+    solver: VelocitySolver,
+) -> tuple[StateDict, VelocitySolver]:
     state = update_velocity(space, space.shaped.concat(), stated.concat())
     contact_with_meta = space.check_contacts(stated.update(state))
     # Check there's any penetration
@@ -976,7 +993,7 @@ def step(space: Space, stated: StateDict, solver: VelocitySolver) -> StateDict:
         contact_with_meta,
     )
     statec = update_position(space, state.replace(v=v, p=p))
-    return stated.update(statec)
+    return stated.update(statec), solver
 
 
 @chex.dataclass
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 6001d9c0..a2ed7613 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -16,7 +16,6 @@
     StateDict,
     _length_to_points,
     _vmap_dot,
-    normalize,
 )
 from emevo.vec2d import Vec2d, Vec2dLike
 
@@ -103,6 +102,8 @@ class SpaceBuilder:
     max_linear_correction: float = 0.2
     allowed_penetration: float = 0.005
     bounce_threshold: float = 1.0
+    max_velocity: float | None = None
+    max_angular_velocity: float | None = None
 
     def add_circle(
         self,
@@ -203,6 +204,10 @@ def concat_or(sl: list[Shape]) -> Shape | None:
         dt = self.dt
         linear_damping = jnp.exp(-dt * self.linear_damping).item()
         angular_damping = jnp.exp(-dt * self.angular_damping).item()
+        max_velocity = jnp.inf if self.max_velocity is None else self.max_velocity
+        max_angular_velocity = (
+            jnp.inf if self.max_angular_velocity is None else self.max_angular_velocity
+        )
         return Space(
             gravity=jnp.array(self.gravity),
             shaped=shaped,
@@ -215,6 +220,8 @@ def concat_or(sl: list[Shape]) -> Shape | None:
             max_linear_correction=self.max_linear_correction,
             allowed_penetration=self.allowed_penetration,
             bounce_threshold=self.bounce_threshold,
+            max_velocity=max_velocity,
+            max_angular_velocity=max_angular_velocity,
         )
 
 
diff --git a/src/emevo/spaces.py b/src/emevo/spaces.py
index 0b8b6411..516ba76f 100644
--- a/src/emevo/spaces.py
+++ b/src/emevo/spaces.py
@@ -216,14 +216,7 @@ def clip(self, x: int) -> int:
 
     def contains(self, x: int) -> bool:
         """Return boolean specifying if x is a valid member of this space."""
-        if isinstance(x, int):
-            as_int = x
-        elif isinstance(x, (jnp.generic, jnp.ndarray)) and (
-            x.dtype.char in jnp.typecodes["AllInteger"] and x.shape == ()
-        ):
-            as_int = int(x)  # type: ignore
-        else:
-            return False
+        as_int = x
         return self.start <= as_int < self.start + self.n
 
     def flatten(self) -> BoxSpace:
diff --git a/src/emevo/vec2d.py b/src/emevo/vec2d.py
index 801e0d76..6ee2e344 100644
--- a/src/emevo/vec2d.py
+++ b/src/emevo/vec2d.py
@@ -73,7 +73,7 @@ class Vec2d(NamedTuple):
 
     # String representaion (for debugging)
     def __repr__(self) -> str:
-        return f"Vec2d({self.x}, {self.y}"
+        return f"Vec2d({self.x}, {self.y})"
 
     # Addition
     def __add__(self, other: tuple[float, float]) -> Self:  # type: ignore

From 51429accdc82cbb7cdba81ac1a3f2c7e6aa35aad Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 24 Oct 2023 16:28:23 +0900
Subject: [PATCH 034/337] Introduce static_circle to reduce the number of
 collision check

---
 smoke-tests/circle_loop.py                    |  8 ++-
 src/emevo/environments/circle_foraging.py     | 42 ++++++++----
 .../{pymunk_envs => }/moderngl_vis.py         |  0
 src/emevo/environments/phyjax2d.py            | 66 ++++++++++++++++---
 src/emevo/environments/phyjax2d_utils.py      | 23 ++++++-
 tests/test_placement.py                       | 19 +++---
 6 files changed, 124 insertions(+), 34 deletions(-)
 rename src/emevo/environments/{pymunk_envs => }/moderngl_vis.py (100%)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index dd31b257..f69f535f 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -57,8 +57,10 @@ def main(
     )
     state = env.reset(jax.random.PRNGKey(43))
 
-    if render is not None:
+    if render:
         visualizer = env.visualizer(state)
+    else:
+        visualizer = None
 
     activate_index = 5
 
@@ -69,8 +71,8 @@ def main(
         # _ = env.step(actions)  # type: ignore
         key, act_key = jax.random.split(state.key)
         state = state.replace(key=key)
-        act = env.act_space.sample(act_key)
-        state = env.step(state, act)
+        act = jax.jit(env.act_space.sample)(act_key)
+        state = jax.jit(env.step)(state, act)
         if i % 1000 == 0:
             if 10 <= activate_index:
                 state, success = env.deactivate(state, activate_index)
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 123af60e..e7b94e8f 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -139,10 +139,20 @@ def _make_physics(
     seg_position = jax.tree_map(lambda *args: jnp.stack(args), *segments)
     seg_state = State.from_position(seg_position)
     for _ in range(n_max_agents):
-        # Use the default density for now
-        builder.add_circle(radius=agent_radius, friction=0.1, elasticity=0.2)
+        builder.add_circle(
+            radius=agent_radius,
+            friction=0.1,
+            elasticity=0.2,
+            density=0.01,
+        )
     for _ in range(n_max_foods):
-        builder.add_circle(radius=food_radius, friction=0.0, elasticity=0.2)
+        builder.add_circle(
+            radius=food_radius,
+            friction=0.0,
+            elasticity=0.2,
+            density=0.1,
+            is_static=True,
+        )
     space = builder.build()
     return space, seg_state
 
@@ -237,10 +247,9 @@ def __init__(
         self._invisible_xy = jnp.array([-100.0, -100.0], dtype=jnp.float32)
         act_p1 = Vec2d(0, agent_radius).rotated(np.pi * 0.75)
         act_p2 = Vec2d(0, agent_radius).rotated(-np.pi * 0.75)
-        N = self._n_max_agents + self._n_max_foods
+        N = self._n_max_agents
         self._act_p1 = jnp.tile(jnp.array(act_p1), (N, 1))
         self._act_p2 = jnp.tile(jnp.array(act_p2), (N, 1))
-        self._act_food = jnp.zeros((self._n_max_foods, 2))
 
     @staticmethod
     def _make_food_num_fn(
@@ -313,7 +322,6 @@ def set_agent_loc_fn(self, agent_loc_fn: str | tuple | InitLocFn) -> None:
 
     def step(self, state: CFState, action: ArrayLike) -> CFState:
         act = self.act_space.clip(jnp.array(action))
-        act = jnp.concatenate((act, self._act_food), axis=0)
         f1, f2 = act[:, 0], act[:, 1]
         f1 = jnp.stack((jnp.zeros_like(f1), f1), axis=1)
         f2 = jnp.stack((jnp.zeros_like(f2), f2), axis=1)
@@ -322,7 +330,7 @@ def step(self, state: CFState, action: ArrayLike) -> CFState:
         circle = circle.apply_force_local(self._act_p2, f2)
         stated = state.physics.replace(circle=circle)
         stated, solver = physics_step(self._physics, stated, state.solver)
-        return state.replace(physics=stated)
+        return state.replace(physics=stated, solver=solver)
 
     def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:
         key, activate_key = jax.random.split(state.key)
@@ -407,20 +415,30 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
         stated = self._physics.shaped.zeros_state()
         assert stated.circle is not None
 
-        is_active = jnp.concatenate(
+        # Set is_active
+        is_active_c = jnp.concatenate(
             (
                 jnp.ones(self._n_initial_agents, dtype=bool),
                 jnp.zeros(self._n_max_agents - self._n_initial_agents, dtype=bool),
+            )
+        )
+        is_active_s = jnp.concatenate(
+            (
                 jnp.ones(self._n_initial_foods, dtype=bool),
                 jnp.zeros(self._n_max_foods - self._n_initial_foods, dtype=bool),
             )
         )
+        stated = stated.nested_replace("circle.is_active", is_active_c)
+        stated = stated.nested_replace("static_circle.is_active", is_active_s)
         # Move all circle to the invisiable area
         stated = stated.nested_replace(
             "circle.p.xy",
             jnp.ones_like(stated.circle.p.xy) * -100,
         )
-        stated = stated.nested_replace("circle.is_active", is_active)
+        stated = stated.nested_replace(
+            "static_circle.p.xy",
+            jnp.ones_like(stated.static_circle.p.xy) * -100,
+        )
         keys = jax.random.split(key, self._n_initial_foods + self._n_initial_agents)
         agent_failed = 0
         for i, key in enumerate(keys[: self._n_initial_agents]):
@@ -459,8 +477,8 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
             )
             if jnp.all(xy < jnp.inf):
                 stated = stated.nested_replace(
-                    "circle.p.xy",
-                    stated.circle.p.xy.at[i + self._n_max_agents].set(xy),
+                    "static_circle.p.xy",
+                    stated.static_circle.p.xy.at[i].set(xy),
                 )
             else:
                 food_failed += 1
@@ -478,7 +496,7 @@ def visualizer(
         **kwargs,
     ) -> Visualizer:
         """Create a visualizer for the environment"""
-        from emevo.environments.pymunk_envs import moderngl_vis
+        from emevo.environments import moderngl_vis
 
         return moderngl_vis.MglVisualizer(
             x_range=self._x_range,
diff --git a/src/emevo/environments/pymunk_envs/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
similarity index 100%
rename from src/emevo/environments/pymunk_envs/moderngl_vis.py
rename to src/emevo/environments/moderngl_vis.py
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index ad95ecc8..16a615db 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -430,8 +430,10 @@ def _capsule_to_circle_impl(
 @chex.dataclass
 class StateDict:
     circle: State | None = None
+    static_circle: State | None = None
     segment: State | None = None
     capsule: State | None = None
+    static_capsule: State | None = None
 
     def concat(self) -> Self:
         states = [s for s in self.values() if s is not None]
@@ -456,9 +458,17 @@ def _get(self, name: str, state: State) -> State | None:
 
     def update(self, statec: State) -> Self:
         circle = self._get("circle", statec)
+        static_circle = self._get("static_circle", statec)
         segment = self._get("segment", statec)
         capsule = self._get("capsule", statec)
-        return self.__class__(circle=circle, segment=segment, capsule=capsule)
+        static_capsule = self._get("static_capsule", statec)
+        return self.__class__(
+            circle=circle,
+            static_circle=static_circle,
+            segment=segment,
+            capsule=capsule,
+            static_capsule=static_capsule,
+        )
 
     def nested_replace(self, query: str, value: Any) -> Self:
         """Convenient method for nested replace"""
@@ -475,8 +485,10 @@ def nested_replace(self, query: str, value: Any) -> Self:
 @chex.dataclass
 class ShapeDict:
     circle: Circle | None = None
-    segment: Segment | None = None
+    static_circle: Circle | None = None
     capsule: Capsule | None = None
+    static_capsule: Capsule | None = None
+    segment: Segment | None = None
 
     def concat(self) -> Shape:
         shapes = [s.to_shape() for s in self.values() if s is not None]
@@ -484,9 +496,17 @@ def concat(self) -> Shape:
 
     def zeros_state(self) -> StateDict:
         circle = then(self.circle, lambda s: State.zeros(len(s.mass)))
+        static_circle = then(self.static_circle, lambda s: State.zeros(len(s.mass)))
         segment = then(self.segment, lambda s: State.zeros(len(s.mass)))
         capsule = then(self.capsule, lambda s: State.zeros(len(s.mass)))
-        return StateDict(circle=circle, segment=segment, capsule=capsule)
+        static_capsule = then(self.capsule, lambda s: State.zeros(len(s.mass)))
+        return StateDict(
+            circle=circle,
+            static_circle=static_circle,
+            segment=segment,
+            capsule=capsule,
+            static_capsule=static_capsule,
+        )
 
 
 def _circle_to_circle(
@@ -506,6 +526,32 @@ def _circle_to_circle(
     return contacts, circle1, circle2
 
 
+def _circle_to_static_circle(
+    shaped: ShapeDict,
+    stated: StateDict,
+) -> tuple[Contact, Circle, Circle]:
+    circle1 = jax.tree_map(
+        functools.partial(_pair_outer, reps=shaped.static_circle.mass.shape[0]),
+        shaped.circle,
+    )
+    circle2 = jax.tree_map(
+        functools.partial(_pair_inner, reps=shaped.circle.mass.shape[0]),
+        shaped.static_circle,
+    )
+    pos1, pos2 = tree_map2(generate_pairs, stated.circle.p, stated.static_circle.p)
+    is_active = jnp.logical_and(
+        *generate_pairs(stated.circle.is_active, stated.static_circle.is_active)
+    )
+    contacts = _circle_to_circle_impl(
+        circle1,
+        circle2,
+        pos1,
+        pos2,
+        is_active,
+    )
+    return contacts, circle1, circle2
+
+
 def _capsule_to_circle(
     shaped: ShapeDict,
     stated: StateDict,
@@ -560,6 +606,7 @@ def _segment_to_circle(
 
 _CONTACT_FUNCTIONS = {
     ("circle", "circle"): _circle_to_circle,
+    ("circle", "static_circle"): _circle_to_static_circle,
     ("capsule", "circle"): _capsule_to_circle,
     ("segment", "circle"): _segment_to_circle,
 }
@@ -659,19 +706,20 @@ def update_velocity(space: Space, shape: Shape, state: State) -> State:
     )
     v_xy = state.v.xy + (gravity + state.f.xy * invm) * space.dt
     v_ang = state.v.angle + state.f.angle * shape.inv_moment() * space.dt
-    v_xy = jnp.clip(state.v.xy, a_max=space.max_velocity, a_min=-space.max_velocity)
+    v_xy = jnp.clip(
+        v_xy * space.linear_damping,
+        a_max=space.max_velocity,
+        a_min=-space.max_velocity,
+    )
     v_ang = jnp.clip(
-        state.v.angle,
+        v_ang * space.angular_damping,
         a_max=space.max_angular_velocity,
         a_min=-space.max_angular_velocity,
     )
     # Damping: dv/dt + vc = 0 -> v(t) = v0 * exp(-tc)
     # v(t + dt) = v0 * exp(-tc - dtc) = v0 * exp(-tc) * exp(-dtc) = v(t)exp(-dtc)
     # Thus, linear/angular damping factors are actually exp(-dtc)
-    return state.replace(
-        v=Velocity(angle=v_ang * space.angular_damping, xy=v_xy * space.linear_damping),
-        f=state.f.zeros_like(),
-    )
+    return state.replace(v=Velocity(angle=v_ang, xy=v_xy), f=state.f.zeros_like())
 
 
 def update_position(space: Space, state: State) -> State:
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index a2ed7613..01d32dab 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -90,7 +90,9 @@ class SpaceBuilder:
 
     gravity: Vec2dLike = dataclasses.field(default=(0.0, -9.8))
     circles: list[Circle] = dataclasses.field(default_factory=list)
+    static_circles: list[Circle] = dataclasses.field(default_factory=list)
     capsules: list[Capsule] = dataclasses.field(default_factory=list)
+    static_capsules: list[Capsule] = dataclasses.field(default_factory=list)
     segments: list[Segment] = dataclasses.field(default_factory=list)
     dt: float = 0.1
     linear_damping: float = 0.9
@@ -130,7 +132,10 @@ def add_circle(
             friction=jnp.array([friction]),
             rgba=jnp.array(rgba).reshape(1, 4),
         )
-        self.circles.append(circle)
+        if is_static:
+            self.static_circles.append(circle)
+        else:
+            self.circles.append(circle)
 
     def add_capsule(
         self,
@@ -163,7 +168,10 @@ def add_capsule(
             friction=jnp.array([friction]),
             rgba=jnp.array(rgba).reshape(1, 4),
         )
-        self.capsules.append(capsule)
+        if is_static:
+            self.static_capsules.append(capsule)
+        else:
+            self.capsules.append(capsule)
 
     def add_segment(
         self,
@@ -198,8 +206,10 @@ def concat_or(sl: list[Shape]) -> Shape | None:
 
         shaped = ShapeDict(
             circle=concat_or(self.circles),
+            static_circle=concat_or(self.static_circles),
             segment=concat_or(self.segments),
             capsule=concat_or(self.capsules),
+            static_capsule=concat_or(self.static_capsules),
         )
         dt = self.dt
         linear_damping = jnp.exp(-dt * self.linear_damping).item()
@@ -288,6 +298,15 @@ def circle_overwrap(
     else:
         overwrap2cir = jnp.array(False)
 
+     # Circle-static_circle overwrap
+    if stated.static_circle is not None and shaped.static_circle is not None:
+        cpos = stated.static_circle.p.xy
+        # Suppose that cpos.shape == (N, 2) and xy.shape == (2,)
+        dist = jnp.linalg.norm(cpos - jnp.expand_dims(xy, axis=0), axis=-1)
+        penetration = shaped.static_circle.radius + radius - dist
+        has_overwrap = jnp.logical_and(stated.static_circle.is_active, penetration >= 0)
+        overwrap2cir = jnp.logical_or(jnp.any(has_overwrap), overwrap2cir)
+
     # Circle-segment overwrap
 
     if stated.segment is not None and shaped.segment is not None:
diff --git a/tests/test_placement.py b/tests/test_placement.py
index f1dd459e..c080cf52 100644
--- a/tests/test_placement.py
+++ b/tests/test_placement.py
@@ -3,7 +3,7 @@
 import jax.numpy as jnp
 import pytest
 
-from emevo.environments.circle_foraging import _make_space
+from emevo.environments.circle_foraging import _make_physics
 from emevo.environments.phyjax2d import Space, StateDict
 from emevo.environments.placement import place_agent, place_food
 from emevo.environments.utils.food_repr import ReprLoc
@@ -22,7 +22,7 @@ def key() -> chex.PRNGKey:
 
 def get_space_and_more() -> tuple[Space, StateDict, CircleCoordinate]:
     coordinate = CircleCoordinate((100.0, 100.0), 100.0)
-    space, seg_state = _make_space(
+    space, seg_state = _make_physics(
         0.1,
         coordinate,
         n_max_agents=N_MAX_AGENTS,
@@ -56,7 +56,7 @@ def test_place_agents(key) -> None:
     is_active = jnp.concatenate(
         (
             jnp.ones(n, dtype=bool),
-            jnp.zeros(N_MAX_AGENTS + N_MAX_FOODS - n, dtype=bool),
+            jnp.zeros(N_MAX_AGENTS - n, dtype=bool),
         )
     )
     stated = stated.nested_replace("circle.is_active", is_active)
@@ -71,7 +71,7 @@ def test_place_foods(key) -> None:
     keys = jax.random.split(key, n)
     space, stated, coordinate = get_space_and_more()
     reprloc_fn, reprloc_state = ReprLoc.UNIFORM(CircleCoordinate((100.0, 100.0), 95.0))
-    assert stated.circle is not None
+    assert stated.static_circle is not None
     for i, key in enumerate(keys):
         xy = place_food(
             n_trial=10,
@@ -85,18 +85,21 @@ def test_place_foods(key) -> None:
         )
         assert jnp.all(xy < jnp.inf), stated.circle.p.xy
         stated = stated.nested_replace(
-            "circle.p.xy",
-            stated.circle.p.xy.at[i + N_MAX_AGENTS].set(xy),
+            "static_circle.p.xy",
+            stated.static_circle.p.xy.at[i].set(xy),
         )
 
+    stated = stated.nested_replace(
+        "circle.is_active",
+        jnp.zeros(N_MAX_AGENTS, dtype=bool),
+    )
     is_active = jnp.concatenate(
         (
-            jnp.zeros(N_MAX_AGENTS, dtype=bool),
             jnp.ones(n, dtype=bool),
             jnp.zeros(N_MAX_FOODS - n, dtype=bool),
         )
     )
-    stated = stated.nested_replace("circle.is_active", is_active)
+    stated = stated.nested_replace("static_circle.is_active", is_active)
 
     # test no overwrap each other
     contact_data = space.check_contacts(stated)

From 4f58651487e3a0645353721cfdc306ac3f91ff6b Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 24 Oct 2023 22:43:25 +0900
Subject: [PATCH 035/337] Opimize circle_loop example

---
 smoke-tests/circle_loop.py | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index f69f535f..c2e96051 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -1,6 +1,6 @@
 """Example of using circle foraging environment"""
 
-
+import chex
 import enum
 from typing import Any, Optional, Tuple
 
@@ -55,7 +55,9 @@ def main(
         n_initial_agents=6,
         **env_kwargs,
     )
-    state = env.reset(jax.random.PRNGKey(43))
+    key = jax.random.PRNGKey(43)
+    keys = jax.random.split(key, steps + 1)
+    state = env.reset(keys[0])
 
     if render:
         visualizer = env.visualizer(state)
@@ -63,16 +65,13 @@ def main(
         visualizer = None
 
     activate_index = 5
-
-    for i in tqdm(range(steps)):
-        # actions = {body: body.act_space.sample(gen) for body in bodies}
-        # Samples for adding constant force for debugging
-        # actions = {body: np.array([0.0, -1.0]) for body in bodies}
-        # _ = env.step(actions)  # type: ignore
-        key, act_key = jax.random.split(state.key)
-        state = state.replace(key=key)
-        act = jax.jit(env.act_space.sample)(act_key)
-        state = jax.jit(env.step)(state, act)
+    jit_step = jax.jit(env.step)
+    jit_sample = jax.jit(env.act_space.sample)
+    for i, key in tqdm(zip(range(steps), keys[1:])):
+        # key, act_key = jax.random.split(state.key)
+        # state = state.replace(key=key)
+        act = jit_sample(key)
+        state = jit_step(state, act)
         if i % 1000 == 0:
             if 10 <= activate_index:
                 state, success = env.deactivate(state, activate_index)

From a0599755ad1f206b4dfc804b62b065437b747904 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 25 Oct 2023 09:55:11 +0900
Subject: [PATCH 036/337] Test with many agents?

---
 smoke-tests/circle_loop.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index c2e96051..9ff9d7aa 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -30,6 +30,7 @@ def main(
     obstacles: bool = False,
     angle: bool = False,
     render: bool = False,
+    replace: bool = False,
     env_shape: str = "square",
     food_loc_fn: str = "gaussian",
     food_num: FoodNum = FoodNum.CONSTANT,
@@ -51,8 +52,8 @@ def main(
     env = make(
         "CircleForaging-v0",
         env_shape=env_shape,
-        n_max_agents=20,
-        n_initial_agents=6,
+        n_max_agents=50,
+        n_initial_agents=40,
         **env_kwargs,
     )
     key = jax.random.PRNGKey(43)
@@ -72,7 +73,7 @@ def main(
         # state = state.replace(key=key)
         act = jit_sample(key)
         state = jit_step(state, act)
-        if i % 1000 == 0:
+        if replace and i % 1000 == 0:
             if 10 <= activate_index:
                 state, success = env.deactivate(state, activate_index)
                 if not success:

From 96e17cb8a07206657d834c0951b46fe30d1205e2 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 25 Oct 2023 12:01:59 +0900
Subject: [PATCH 037/337] Change the visualizer name

---
 src/emevo/environments/moderngl_vis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index 28872857..f8b02841 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -467,7 +467,7 @@ def __init__(
         hoffsets: tuple[int, ...] = (),
         vsync: bool = False,
         backend: str = "pyglet",
-        title: str = "EmEvo PymunkEnv",
+        title: str = "EmEvo CircleForaging",
     ) -> None:
         self.pix_fmt = "rgba"
 

From 8ab187475689fa2a07497c74187e6e28d380dd15 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 25 Oct 2023 17:25:46 +0900
Subject: [PATCH 038/337] Start implementing indices store

---
 requirements/smoke.in                     |   1 +
 smoke-tests/circle_loop.py                |  21 +-
 src/emevo/environments/circle_foraging.py |  14 +-
 src/emevo/environments/moderngl_vis.py    |  13 +
 src/emevo/environments/phyjax2d.py        |  69 ++-
 src/emevo/environments/phyjax2d_utils.py  |   8 +-
 src/emevo/moderngl_vis.py                 | 629 ----------------------
 7 files changed, 97 insertions(+), 658 deletions(-)
 delete mode 100644 src/emevo/moderngl_vis.py

diff --git a/requirements/smoke.in b/requirements/smoke.in
index 5ee29c24..4b1b0a03 100644
--- a/requirements/smoke.in
+++ b/requirements/smoke.in
@@ -1,3 +1,4 @@
 -e .[moderngl,video,pyside6]
+py-spy  # for profiling
 tqdm
 typer
\ No newline at end of file
diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index 9ff9d7aa..a83f0729 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -22,18 +22,16 @@ class FoodNum(str, enum.Enum):
 def main(
     steps: int = 100,
     seed: int = 1,
+    n_agents: int = 10,
     n_foods: int = 10,
-    n_foods_later: int = 10,
     debug: bool = False,
     forward_sensor: bool = False,
     use_test_env: bool = False,
     obstacles: bool = False,
-    angle: bool = False,
     render: bool = False,
     replace: bool = False,
     env_shape: str = "square",
     food_loc_fn: str = "gaussian",
-    food_num: FoodNum = FoodNum.CONSTANT,
 ) -> None:
     if debug:
         import loguru
@@ -52,11 +50,13 @@ def main(
     env = make(
         "CircleForaging-v0",
         env_shape=env_shape,
-        n_max_agents=50,
-        n_initial_agents=40,
+        n_max_agents=n_agents + 10,
+        n_initial_agents=n_agents,
+        food_num_fn=("constant", n_foods),
+        food_loc_fn=food_loc_fn,
         **env_kwargs,
     )
-    key = jax.random.PRNGKey(43)
+    key = jax.random.PRNGKey(seed)
     keys = jax.random.split(key, steps + 1)
     state = env.reset(keys[0])
 
@@ -65,16 +65,13 @@ def main(
     else:
         visualizer = None
 
-    activate_index = 5
+    activate_index = n_agents
     jit_step = jax.jit(env.step)
     jit_sample = jax.jit(env.act_space.sample)
     for i, key in tqdm(zip(range(steps), keys[1:])):
-        # key, act_key = jax.random.split(state.key)
-        # state = state.replace(key=key)
-        act = jit_sample(key)
-        state = jit_step(state, act)
+        state = jit_step(state, jit_sample(key))
         if replace and i % 1000 == 0:
-            if 10 <= activate_index:
+            if n_agents + 5 <= activate_index:
                 state, success = env.deactivate(state, activate_index)
                 if not success:
                     print(f"Failed to deactivate agent! {activate_index}")
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index e7b94e8f..95e5731f 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import warnings
 from typing import Any, Callable, Literal, NamedTuple
 
@@ -13,6 +15,7 @@
 from emevo.environments.phyjax2d import State, StateDict, Velocity, VelocitySolver
 from emevo.environments.phyjax2d import step as physics_step
 from emevo.environments.phyjax2d_utils import (
+    Color,
     SpaceBuilder,
     make_approx_circle,
     make_square,
@@ -39,6 +42,8 @@
 MAX_ANGULAR_VELOCITY: float = float(np.pi)
 MAX_VELOCITY: float = 10.0
 MAX_FORCE: float = 1.0
+AGENT_COLOR: Color = Color(2, 204, 254)
+FOOD_COLOR: Color = Color(254, 2, 162)
 
 
 class CFObs(NamedTuple):
@@ -144,6 +149,7 @@ def _make_physics(
             friction=0.1,
             elasticity=0.2,
             density=0.01,
+            color=AGENT_COLOR,
         )
     for _ in range(n_max_foods):
         builder.add_circle(
@@ -151,10 +157,10 @@ def _make_physics(
             friction=0.0,
             elasticity=0.2,
             density=0.1,
+            color=FOOD_COLOR,
             is_static=True,
         )
-    space = builder.build()
-    return space, seg_state
+    return builder.build(), seg_state
 
 
 class CircleForaging(Env):
@@ -323,8 +329,8 @@ def set_agent_loc_fn(self, agent_loc_fn: str | tuple | InitLocFn) -> None:
     def step(self, state: CFState, action: ArrayLike) -> CFState:
         act = self.act_space.clip(jnp.array(action))
         f1, f2 = act[:, 0], act[:, 1]
-        f1 = jnp.stack((jnp.zeros_like(f1), f1), axis=1)
-        f2 = jnp.stack((jnp.zeros_like(f2), f2), axis=1)
+        f1 = jnp.stack((jnp.zeros_like(f1), f1), axis=1) * -self._act_p1
+        f2 = jnp.stack((jnp.zeros_like(f2), f2), axis=1) * -self._act_p2
         circle = state.physics.circle
         circle = circle.apply_force_local(self._act_p1, f1)
         circle = circle.apply_force_local(self._act_p2, f2)
diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index f8b02841..cc0213e0 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -334,6 +334,18 @@ def __init__(
             scales=scales,
             colors=colors,
         )
+        points, scales, colors = _collect_circles(
+            space.shaped.static_circle,
+            stated.static_circle,
+            self._circle_scaling ,
+        )
+        self._static_circles = CircleVA(
+            ctx=context,
+            program=circle_program,
+            points=points,
+            scales=scales,
+            colors=colors,
+        )
         static_segment_program = self._make_gl_program(
             vertex_shader=_LINE_VERTEX_SHADER,
             geometry_shader=_LINE_GEOMETRY_SHADER,
@@ -447,6 +459,7 @@ def render(self, stated: StateDict) -> None:
         # sensors = _collect_sensors(shapes)
         # if self._sensors.update(sensors):
         #     self._sensors.render()
+        self._static_circles.render()
         self._static_lines.render()
 
 
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 16a615db..7d3838c8 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -1,3 +1,4 @@
+import dataclasses
 import functools
 from collections.abc import Sequence
 from typing import Any, Callable, Protocol
@@ -509,21 +510,54 @@ def zeros_state(self) -> StateDict:
         )
 
 
-def _circle_to_circle(
-    shaped: ShapeDict,
+@chex.dataclass
+class ContactIndices:
+    shape1: Shape
+    shape2: Shape
+    index1: jax.Array
+    index2: jax.Array
+
+
+_jitted_self_pairs = jax.jit(generate_self_pairs)
+
+
+# This fuction is used within post_init so need to jit
+def _circle_to_circle_index(shaped: ShapeDict) -> ContactIndices:
+    circle1, circle2 = tree_map2(_jitted_self_pairs, shaped.circle)
+    n = shaped.circle.mass.shape[0]
+    index1, index2 = _jitted_self_pairs(jnp.arange(n))
+    return ContactIndices(
+        shape1=circle1,
+        shape2=circle2,
+        index1=index1,
+        index2=index2,
+    )
+
+
+def _circle_to_circle_new(
+    ci: ContactIndices,
     stated: StateDict,
 ) -> tuple[Contact, Circle, Circle]:
-    circle1, circle2 = tree_map2(generate_self_pairs, shaped.circle)
-    pos1, pos2 = tree_map2(generate_self_pairs, stated.circle.p)
-    is_active = jnp.logical_and(*generate_self_pairs(stated.circle.is_active))
+    pos1 = jax.tree_map(lambda arr: arr[ci.index1], stated.circle.p)
+    pos2 = jax.tree_map(lambda arr: arr[ci.index2], stated.circle.p)
+    is_active1 = stated.circle.is_active[ci.index1]
+    is_active2 = stated.circle.is_active[ci.index2]
     contacts = _circle_to_circle_impl(
-        circle1,
-        circle2,
+        ci.shape1,
+        ci.shape2,
         pos1,
         pos2,
-        is_active,
+        jnp.logical_and(is_active1, is_active2),
     )
-    return contacts, circle1, circle2
+    return contacts, ci.shape1, ci.shape2
+
+
+def _circle_to_circle(
+    shaped: ShapeDict,
+    stated: StateDict,
+) -> tuple[Contact, Circle, Circle]:
+    ci = _circle_to_circle_index(shaped)
+    return _circle_to_circle_new(ci, stated)
 
 
 def _circle_to_static_circle(
@@ -604,6 +638,14 @@ def _segment_to_circle(
     return contacts, segment, circle
 
 
+_CONTACT_INDEX_FUNCTIONS = {
+    ("circle", "circle"): _circle_to_circle,
+    ("circle", "static_circle"): _circle_to_static_circle,
+    ("capsule", "circle"): _capsule_to_circle,
+    ("segment", "circle"): _segment_to_circle,
+}
+
+
 _CONTACT_FUNCTIONS = {
     ("circle", "circle"): _circle_to_circle,
     ("circle", "static_circle"): _circle_to_static_circle,
@@ -649,6 +691,15 @@ class Space:
     bounce_threshold: float = 1.0
     max_velocity: float = 100.0
     max_angular_velocity: float = 100.0
+    contact_helpers: dict[tuple[str, str]] = dataclasses.field(
+        default_factory=dict,
+        init=False,
+    )
+
+    def __post_init__(self) -> None:
+        for (n1, n2), fn in _CONTACT_INDEX_FUNCTIONS.items():
+            if self.shaped[n1] is not None and self.shaped[n2] is not None:
+                pass
 
     def check_contacts(self, stated: StateDict) -> ContactWithMetadata:
         contacts = []
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 01d32dab..294dedee 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -115,7 +115,7 @@ def add_circle(
         is_static: bool = False,
         friction: float = 0.8,
         elasticity: float = 0.8,
-        rgba: Color = _BLACK,
+        color: Color = _BLACK,
     ) -> None:
         _check_params_positive(
             friction=friction,
@@ -130,7 +130,7 @@ def add_circle(
             moment=moment,
             elasticity=jnp.array([elasticity]),
             friction=jnp.array([friction]),
-            rgba=jnp.array(rgba).reshape(1, 4),
+            rgba=jnp.array(color).reshape(1, 4),
         )
         if is_static:
             self.static_circles.append(circle)
@@ -146,7 +146,7 @@ def add_capsule(
         is_static: bool = False,
         friction: float = 0.8,
         elasticity: float = 0.8,
-        rgba: Color = _BLACK,
+        color: Color = _BLACK,
     ) -> None:
         _check_params_positive(
             friction=friction,
@@ -166,7 +166,7 @@ def add_capsule(
             moment=moment,
             elasticity=jnp.array([elasticity]),
             friction=jnp.array([friction]),
-            rgba=jnp.array(rgba).reshape(1, 4),
+            rgba=jnp.array(color).reshape(1, 4),
         )
         if is_static:
             self.static_capsules.append(capsule)
diff --git a/src/emevo/moderngl_vis.py b/src/emevo/moderngl_vis.py
deleted file mode 100644
index db980c1c..00000000
--- a/src/emevo/moderngl_vis.py
+++ /dev/null
@@ -1,629 +0,0 @@
-"""
-A simple but fast visualizer based on moderngl.
-Currently, only supports circles and lines.
-"""
-from __future__ import annotations
-
-from typing import Any, ClassVar, Iterable
-
-import moderngl as mgl
-import moderngl_window as mglw
-import numpy as np
-import pymunk
-from moderngl_window.context import headless
-from numpy.typing import NDArray
-
-from emevo.environments.pymunk_envs.pymunk_env import PymunkEnv
-
-_CIRCLE_VERTEX_SHADER = """
-#version 330
-uniform mat4 proj;
-in vec2 in_position;
-in float in_scale;
-in vec4 in_color;
-out vec4 v_color;
-void main() {
-    gl_Position = proj * vec4(in_position, 0.0, 1.0);
-    gl_PointSize = in_scale;
-    v_color = in_color;
-}
-"""
-
-# Smoothing by fwidth is based on: https://rubendv.be/posts/fwidth/
-_CIRCLE_FRAGMENT_SHADER = """
-#version 330
-in vec4 v_color;
-out vec4 f_color;
-void main() {
-    float dist = length(gl_PointCoord.xy - vec2(0.5));
-    float delta = fwidth(dist);
-    float alpha = smoothstep(0.45, 0.45 - delta, dist);
-    f_color = v_color * alpha;
-}
-"""
-
-_LINE_VERTEX_SHADER = """
-#version 330
-in vec2 in_position;
-uniform mat4 proj;
-void main() {
-    gl_Position = proj * vec4(in_position, 0.0, 1.0);
-}
-"""
-
-_LINE_GEOMETRY_SHADER = """
-#version 330
-layout (lines) in;
-layout (triangle_strip, max_vertices = 4) out;
-uniform float width;
-void main() {
-    vec2 a = gl_in[0].gl_Position.xy;
-    vec2 b = gl_in[1].gl_Position.xy;
-    vec2 a2b = b - a;
-    vec2 a2left = vec2(-a2b.y, a2b.x) / length(a2b) * width;
-
-    vec4 positions[4] = vec4[4](
-        vec4(a - a2left, 0.0, 1.0),
-        vec4(a + a2left, 0.0, 1.0),
-        vec4(b - a2left, 0.0, 1.0),
-        vec4(b + a2left, 0.0, 1.0)
-    );
-    for (int i = 0; i < 4; ++i) {
-        gl_Position = positions[i];
-        EmitVertex();
-    }
-    EndPrimitive();
-}
-"""
-
-_LINE_FRAGMENT_SHADER = """
-#version 330
-out vec4 f_color;
-uniform vec4 color;
-void main() {
-    f_color = color;
-}
-"""
-
-
-_ARROW_GEOMETRY_SHADER = """
-#version 330
-layout (lines) in;
-layout (triangle_strip, max_vertices = 7) out;
-uniform mat4 proj;
-void main() {
-    vec2 a = gl_in[0].gl_Position.xy;
-    vec2 b = gl_in[1].gl_Position.xy;
-    vec2 a2b = b - a;
-    float a2b_len = length(a2b);
-    float width = min(0.004, a2b_len * 0.12);
-    vec2 a2left = vec2(-a2b.y, a2b.x) / length(a2b) * width;
-    vec2 c = a + a2b * 0.5;
-    vec2 c2head = a2left * 2.5;
-
-    vec4 positions[7] = vec4[7](
-        vec4(a - a2left, 0.0, 1.0),
-        vec4(a + a2left, 0.0, 1.0),
-        vec4(c - a2left, 0.0, 1.0),
-        vec4(c + a2left, 0.0, 1.0),
-        vec4(c - c2head, 0.0, 1.0),
-        vec4(b, 0.0, 1.0),
-        vec4(c + c2head, 0.0, 1.0)
-    );
-    for (int i = 0; i < 7; ++i) {
-        gl_Position = positions[i];
-        EmitVertex();
-    }
-    EndPrimitive();
-}
-"""
-
-_TEXTURE_VERTEX_SHADER = """
-#version 330
-uniform mat4 proj;
-in vec2 in_position;
-in vec2 in_uv;
-out vec2 uv;
-void main() {
-    gl_Position = proj * vec4(in_position, 0.0, 1.0);
-    uv = in_uv;
-}
-"""
-
-_TEXTURE_FRAGMENT_SHADER = """
-#version 330
-uniform sampler2D image;
-in vec2 uv;
-out vec4 f_color;
-void main() {
-    f_color = vec4(texture(image, uv).rgb, 1.0);
-}
-"""
-
-
-class Renderable:
-    MODE: ClassVar[int]
-    vertex_array: mgl.VertexArray
-
-    def render(self) -> None:
-        self.vertex_array.render(mode=self.MODE)
-
-
-class CircleVA(Renderable):
-    MODE = mgl.POINTS
-
-    def __init__(
-        self,
-        ctx: mgl.Context,
-        program: mgl.Program,
-        points: NDArray,
-        scales: NDArray,
-        colors: NDArray,
-    ) -> None:
-        self._ctx = ctx
-        self._length = points.shape[0]
-        self._points = ctx.buffer(reserve=len(points) * 4 * 2 * 10)
-        self._scales = ctx.buffer(reserve=len(scales) * 4 * 10)
-        self._colors = ctx.buffer(reserve=len(colors) * 4 * 4 * 10)
-
-        self.vertex_array = ctx.vertex_array(
-            program,
-            [
-                (self._points, "2f", "in_position"),
-                (self._scales, "f", "in_scale"),
-                (self._colors, "4f", "in_color"),
-            ],
-        )
-        self.update(points, scales, colors)
-
-    def update(self, points: NDArray, scales: NDArray, colors: NDArray) -> bool:
-        length = points.shape[0]
-        if self._length != length:
-            self._length = length
-            self._points.orphan(length * 4 * 2)
-            self._scales.orphan(length * 4)
-            self._colors.orphan(length * 4 * 4)
-        self._points.write(points)
-        self._scales.write(scales)
-        self._colors.write(colors)
-        return length > 0
-
-
-class SegmentVA(Renderable):
-    MODE = mgl.LINES
-
-    def __init__(
-        self,
-        ctx: mgl.Context,
-        program: mgl.Program,
-        segments: NDArray,
-    ) -> None:
-        self._ctx = ctx
-        self._length = segments.shape[0]
-        self._segments = ctx.buffer(reserve=len(segments) * 4 * 2 * 10)
-
-        self.vertex_array = ctx.vertex_array(
-            program,
-            [(self._segments, "2f", "in_position")],
-        )
-        self.update(segments)
-
-    def update(self, segments: NDArray) -> bool:
-        length = segments.shape[0]
-        if self._length != length:
-            self._length = length
-            self._segments.orphan(length * 4 * 2)
-        self._segments.write(segments)
-        return length > 0
-
-
-class TextureVA(Renderable):
-    MODE = mgl.TRIANGLE_STRIP
-
-    def __init__(
-        self,
-        ctx: mgl.Context,
-        program: mgl.Program,
-        texture: mgl.Texture,
-    ) -> None:
-        self._ctx = ctx
-        self._texture = texture
-        quad_mat = np.array(
-            # x, y, u, v
-            [
-                [0, 1, 0, 1],  # upper left
-                [0, 0, 0, 0],  # lower left
-                [1, 1, 1, 1],  # upper right
-                [1, 0, 1, 0],  # lower right
-            ],
-            dtype=np.float32,
-        )
-        quad_mat_buffer = ctx.buffer(data=quad_mat)
-        self.vertex_array = ctx.vertex_array(
-            program,
-            [(quad_mat_buffer, "2f 2f", "in_position", "in_uv")],
-        )
-
-    def update(self, image: bytes) -> None:
-        self._texture.write(image)
-        self._texture.use()
-
-
-def _collect_circles(
-    shapes: list[pymunk.Shape],
-    circle_scaling: float,
-) -> tuple[NDArray, NDArray, NDArray]:
-    points = []
-    scales = []
-    colors = []
-    for circle in filter(lambda shape: isinstance(shape, pymunk.Circle), shapes):
-        points.append(circle.body.position + circle.offset)
-        scales.append(circle.radius * circle_scaling)
-        colors.append(circle.color)
-    return (
-        np.array(points, dtype=np.float32),
-        np.array(scales, dtype=np.float32),
-        np.array(colors, dtype=np.float32) / 255.0,
-    )
-
-
-def _collect_static_lines(shapes: list[pymunk.Shape]) -> NDArray:
-    points = []
-    for segment in filter(lambda shape: isinstance(shape, pymunk.Segment), shapes):
-        body = segment.body
-        if body.body_type != pymunk.Body.STATIC:
-            continue
-        points.append(segment.a)
-        points.append(segment.b)
-    return np.array(points, dtype=np.float32)
-
-
-def _collect_sensors(shapes: list[pymunk.Shape]) -> NDArray:
-    points = []
-    for segment in filter(lambda shape: isinstance(shape, pymunk.Segment), shapes):
-        body = segment.body
-        if body.body_type == pymunk.Body.STATIC:
-            continue
-        pos = segment.body.position
-        angle = segment.body.angle
-        points.append(segment.a.rotated(angle) + pos)
-        points.append(segment.b.rotated(angle) + pos)
-    return np.array(points, dtype=np.float32)
-
-
-def _collect_heads(shapes: list[pymunk.Shape]) -> NDArray:
-    points = []
-    for circle in filter(lambda shape: isinstance(shape, pymunk.Circle), shapes):
-        pos = circle.body.position + circle.offset
-        angle = circle.body.angle
-        points.append(pymunk.Vec2d(0.0, circle.radius * 0.8).rotated(angle) + pos)
-        points.append(pymunk.Vec2d(0.0, circle.radius * 1.2).rotated(angle) + pos)
-    return np.array(points, dtype=np.float32)
-
-
-def _collect_policies(
-    bodies_and_policies: Iterable[tuple[pymunk.Body, NDArray]],
-    max_arrow_length: float,
-) -> NDArray:
-    max_f = max(map(lambda bp: bp[1].max(), bodies_and_policies))
-    policy_scaling = max_arrow_length / max_f
-    points = []
-    radius = None
-    for body, policy in bodies_and_policies:
-        a = body.position
-        if radius is None:
-            radius = next(
-                filter(lambda shape: isinstance(shape, pymunk.Circle), body.shapes)
-            ).radius
-        f1, f2 = policy
-        from1 = a + pymunk.Vec2d(0, radius).rotated(body.angle + np.pi * 0.75)
-        to1 = from1 + pymunk.Vec2d(0, -f1 * policy_scaling).rotated(body.angle)
-        from2 = a + pymunk.Vec2d(0, radius).rotated(body.angle - np.pi * 0.75)
-        to2 = from2 + pymunk.Vec2d(0, -f2 * policy_scaling).rotated(body.angle)
-        points.append(from1)
-        points.append(to1)
-        points.append(from2)
-        points.append(to2)
-    return np.array(points, dtype=np.float32)
-
-
-def _get_clip_ranges(lengthes: list[float]) -> list[tuple[float, float]]:
-    """Clip ranges to [-1, 1]"""
-    total = sum(lengthes)
-    res = []
-    left = -1.0
-    for length in lengthes:
-        right = left + 2.0 * length / total
-        res.append((left, right))
-        left = right
-    return res
-
-
-class MglRenderer:
-    """Render pymunk environments to the given moderngl context."""
-
-    def __init__(
-        self,
-        context: mgl.Context,
-        screen_width: int,
-        screen_height: int,
-        x_range: float,
-        y_range: float,
-        env: PymunkEnv,
-        voffsets: tuple[int, ...] = (),
-        hoffsets: tuple[int, ...] = (),
-    ) -> None:
-        self._context = context
-
-        self._screen_x = _get_clip_ranges([screen_width, *hoffsets])
-        self._screen_y = _get_clip_ranges([screen_height, *voffsets])
-        self._x_range, self._y_range = x_range, y_range
-        self._range_min = min(x_range, y_range)
-        if x_range < y_range:
-            self._range_min = x_range
-            self._circle_scaling = screen_width / x_range * 2
-        else:
-            self._range_min = y_range
-            self._circle_scaling = screen_height / y_range * 2
-
-        circle_program = self._make_gl_program(
-            vertex_shader=_CIRCLE_VERTEX_SHADER,
-            fragment_shader=_CIRCLE_FRAGMENT_SHADER,
-        )
-        shapes = env.get_space().shapes
-        points, scales, colors = _collect_circles(shapes, self._circle_scaling)
-        self._circles = CircleVA(
-            ctx=context,
-            program=circle_program,
-            points=points,
-            scales=scales,
-            colors=colors,
-        )
-        segment_program = self._make_gl_program(
-            vertex_shader=_LINE_VERTEX_SHADER,
-            geometry_shader=_LINE_GEOMETRY_SHADER,
-            fragment_shader=_LINE_FRAGMENT_SHADER,
-            color=np.array([0.0, 0.0, 0.0, 0.2], dtype=np.float32),
-            width=np.array([0.002], dtype=np.float32),
-        )
-        self._sensors = SegmentVA(
-            ctx=context,
-            program=segment_program,
-            segments=_collect_sensors(shapes),
-        )
-        static_segment_program = self._make_gl_program(
-            vertex_shader=_LINE_VERTEX_SHADER,
-            geometry_shader=_LINE_GEOMETRY_SHADER,
-            fragment_shader=_LINE_FRAGMENT_SHADER,
-            color=np.array([0.0, 0.0, 0.0, 0.4], dtype=np.float32),
-            width=np.array([0.004], dtype=np.float32),
-        )
-        self._static_lines = SegmentVA(
-            ctx=context,
-            program=static_segment_program,
-            segments=_collect_static_lines(shapes),
-        )
-        head_program = self._make_gl_program(
-            vertex_shader=_LINE_VERTEX_SHADER,
-            geometry_shader=_LINE_GEOMETRY_SHADER,
-            fragment_shader=_LINE_FRAGMENT_SHADER,
-            color=np.array([0.5, 0.0, 1.0, 1.0], dtype=np.float32),
-            width=np.array([0.004], dtype=np.float32),
-        )
-        self._heads = SegmentVA(
-            ctx=context,
-            program=head_program,
-            segments=_collect_heads(shapes),
-        )
-        self._overlays = {}
-
-    def _make_gl_program(
-        self,
-        vertex_shader: str,
-        geometry_shader: str | None = None,
-        fragment_shader: str | None = None,
-        screen_idx: tuple[int, int] = (0, 0),
-        game_x: tuple[float, float] | None = None,
-        game_y: tuple[float, float] | None = None,
-        **kwargs: NDArray,
-    ) -> mgl.Program:
-        self._context.enable(mgl.PROGRAM_POINT_SIZE | mgl.BLEND)
-        self._context.blend_func = mgl.DEFAULT_BLENDING
-        prog = self._context.program(
-            vertex_shader=vertex_shader,
-            geometry_shader=geometry_shader,
-            fragment_shader=fragment_shader,
-        )
-        proj = _make_projection_matrix(
-            game_x=game_x or (0, self._x_range),
-            game_y=game_y or (0, self._y_range),
-            screen_x=self._screen_x[screen_idx[0]],
-            screen_y=self._screen_y[screen_idx[1]],
-        )
-        prog["proj"].write(proj)  # type: ignore
-        for key, value in kwargs.items():
-            prog[key].write(value)  # type: ignore
-        return prog
-
-    def overlay(self, name: str, value: Any) -> Any:
-        """Render additional value as an overlay"""
-        key = name.lower()
-        if key == "arrow":
-            segments = _collect_policies(value, self._range_min * 0.1)
-            if "arrow" in self._overlays:
-                do_render = self._overlays["arrow"].update(segments)
-            else:
-                arrow_program = self._make_gl_program(
-                    vertex_shader=_LINE_VERTEX_SHADER,
-                    geometry_shader=_ARROW_GEOMETRY_SHADER,
-                    fragment_shader=_LINE_FRAGMENT_SHADER,
-                    color=np.array([0.98, 0.45, 0.45, 1.0], dtype=np.float32),
-                )
-                self._overlays["arrow"] = SegmentVA(
-                    ctx=self._context,
-                    program=arrow_program,
-                    segments=segments,
-                )
-                do_render = True
-            if do_render:
-                self._overlays["arrow"].render()
-        elif key.startswith("stack"):
-            xi, yi = map(int, key.split("-")[1:])
-            image = np.flipud(value)
-            h, w = image.shape[:2]
-            image_bytes = image.tobytes()
-            if key not in self._overlays:
-                texture = self._context.texture((w, h), 3, image_bytes)
-                texture.build_mipmaps()
-                program = self._make_gl_program(
-                    vertex_shader=_TEXTURE_VERTEX_SHADER,
-                    fragment_shader=_TEXTURE_FRAGMENT_SHADER,
-                    screen_idx=(xi, yi),
-                    game_x=(0.0, 1.0),
-                    game_y=(0.0, 1.0),
-                )
-                self._overlays[key] = TextureVA(self._context, program, texture)
-            self._overlays[key].update(image_bytes)
-            self._overlays[key].render()
-        else:
-            raise ValueError(f"Unsupported overlay in moderngl visualizer: {name}")
-
-    def render(self, env: PymunkEnv) -> None:
-        shapes = env.get_space().shapes
-
-        if self._circles.update(*_collect_circles(shapes, self._circle_scaling)):
-            self._circles.render()
-        if self._heads.update(_collect_heads(shapes)):
-            self._heads.render()
-        sensors = _collect_sensors(shapes)
-        if self._sensors.update(sensors):
-            self._sensors.render()
-        self._static_lines.render()
-
-
-class MglVisualizer:
-    """
-    Visualizer class that follows the `emevo.Visualizer` protocol.
-    Considered as a main interface to use this visualizer.
-    """
-
-    def __init__(
-        self,
-        x_range: float,
-        y_range: float,
-        env: PymunkEnv,
-        figsize: tuple[float, float] | None = None,
-        voffsets: tuple[int, ...] = (),
-        hoffsets: tuple[int, ...] = (),
-        vsync: bool = False,
-        backend: str = "pyglet",
-        title: str = "EmEvo PymunkEnv",
-    ) -> None:
-        self.pix_fmt = "rgba"
-
-        if figsize is None:
-            figsize = x_range * 3.0, y_range * 3.0
-        w, h = int(figsize[0]), int(figsize[1])
-        self._figsize = w + int(sum(hoffsets)), h + int(sum(voffsets))
-
-        self._window = _make_window(
-            title=title,
-            size=self._figsize,
-            backend=backend,
-            vsync=vsync,
-        )
-        self._renderer = MglRenderer(
-            context=self._window.ctx,
-            screen_width=w,
-            screen_height=h,
-            x_range=x_range,
-            y_range=y_range,
-            env=env,
-            voffsets=voffsets,
-            hoffsets=hoffsets,
-        )
-
-    def close(self) -> None:
-        self._window.close()
-
-    def get_image(self) -> NDArray:
-        output = np.frombuffer(
-            self._window.fbo.read(components=4, dtype="f1"),
-            dtype=np.uint8,
-        )
-        w, h = self._figsize
-        return output.reshape(h, w, -1)[::-1]
-
-    def overlay(self, name: str, value: Any) -> None:
-        self._renderer.overlay(name, value)
-
-    def render(self, env: PymunkEnv) -> None:
-        self._window.clear(1.0, 1.0, 1.0)
-        self._window.use()
-        self._renderer.render(env=env)
-
-    def show(self) -> None:
-        self._window.swap_buffers()
-
-
-class _EglHeadlessWindow(headless.Window):
-    name = "egl-headless"
-
-    def init_mgl_context(self) -> None:
-        """Create an standalone context and framebuffer"""
-        self._ctx = mgl.create_standalone_context(
-            require=self.gl_version_code,
-            backend="egl",  # type: ignore
-        )
-        self._fbo = self.ctx.framebuffer(
-            color_attachments=self.ctx.texture(self.size, 4, samples=self._samples),
-            depth_attachment=self.ctx.depth_texture(self.size, samples=self._samples),
-        )
-        self.use()
-
-
-def _make_window(
-    *,
-    title: str,
-    size: tuple[int, int],
-    backend: str,
-    **kwargs,
-) -> mglw.BaseWindow:
-    if backend == "headless":
-        window_cls = _EglHeadlessWindow
-    else:
-        window_cls = mglw.get_window_cls(f"moderngl_window.context.{backend}.Window")
-    window = window_cls(title=title, gl_version=(4, 1), size=size, **kwargs)
-    mglw.activate_context(ctx=window.ctx)
-    return window
-
-
-def _make_projection_matrix(
-    game_x: tuple[float, float] = (0.0, 1.0),
-    game_y: tuple[float, float] = (0.0, 1.0),
-    screen_x: tuple[float, float] = (-1.0, 1.0),
-    screen_y: tuple[float, float] = (-1.0, 1.0),
-) -> NDArray:
-    screen_width = screen_x[1] - screen_x[0]
-    screen_height = screen_y[1] - screen_y[0]
-    x_scale = screen_width / (game_x[1] - game_x[0])
-    y_scale = screen_height / (game_y[1] - game_y[0])
-    scale_mat = np.array(
-        [
-            [x_scale, 0, 0, 0],
-            [0, y_scale, 0, 0],
-            [0, 0, 0, 0],
-            [0, 0, 0, 1],
-        ],
-        dtype=np.float32,
-    )
-    trans_mat = np.array(
-        [
-            [1, 0, 0, (sum(screen_x) - sum(game_x)) / screen_width],
-            [0, 1, 0, (sum(screen_y) - sum(game_y)) / screen_height],
-            [0, 0, 1, 0],
-            [0, 0, 0, 1],
-        ],
-        dtype=np.float32,
-    )
-    return np.ascontiguousarray(np.dot(scale_mat, trans_mat).T)

From a381928ec40ee1f14b29614f4b25af97702ed27b Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 26 Oct 2023 12:03:55 +0900
Subject: [PATCH 039/337] Introduce ContactIndices to pre-compute loop indices

---
 src/emevo/environments/phyjax2d.py | 225 ++++++++++++-----------------
 1 file changed, 91 insertions(+), 134 deletions(-)

diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 7d3838c8..ba2950ce 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -518,132 +518,91 @@ class ContactIndices:
     index2: jax.Array
 
 
+# These fuctions are used in __post_init__ so need to jit
 _jitted_self_pairs = jax.jit(generate_self_pairs)
+_jitted_pairs = jax.jit(generate_pairs)
+_jitted_pair_outer = jax.jit(_pair_outer, static_argnums=(1,))
+_jitted_pair_inner = jax.jit(_pair_inner, static_argnums=(1,))
 
 
-# This fuction is used within post_init so need to jit
-def _circle_to_circle_index(shaped: ShapeDict) -> ContactIndices:
-    circle1, circle2 = tree_map2(_jitted_self_pairs, shaped.circle)
-    n = shaped.circle.mass.shape[0]
-    index1, index2 = _jitted_self_pairs(jnp.arange(n))
+def _self_ci(shape: Shape) -> ContactIndices:
+    shape1, shape2 = tree_map2(_jitted_self_pairs, shape)
+    index1, index2 = _jitted_self_pairs(jnp.arange(shape.mass.shape[0]))
     return ContactIndices(
-        shape1=circle1,
-        shape2=circle2,
+        shape1=shape1,
+        shape2=shape2,
         index1=index1,
         index2=index2,
     )
 
 
-def _circle_to_circle_new(
-    ci: ContactIndices,
-    stated: StateDict,
-) -> tuple[Contact, Circle, Circle]:
+def _pair_ci(shape1: Shape, shape2: Shape) -> ContactIndices:
+    n1, n2 = shape1.mass.shape[0], shape2.mass.shape[0]
+    s1_extended = jax.tree_map(functools.partial(_jitted_pair_outer, reps=n2), shape1)
+    s2_extended = jax.tree_map(functools.partial(_jitted_pair_inner, reps=n1), shape2)
+    index1, index2 = _jitted_pairs(jnp.arange(n1), jnp.arange(n2))
+    return ContactIndices(
+        shape1=s1_extended,
+        shape2=s2_extended,
+        index1=index1,
+        index2=index2,
+    )
+
+
+def _circle_to_circle(ci: ContactIndices, stated: StateDict) -> Contact:
     pos1 = jax.tree_map(lambda arr: arr[ci.index1], stated.circle.p)
     pos2 = jax.tree_map(lambda arr: arr[ci.index2], stated.circle.p)
     is_active1 = stated.circle.is_active[ci.index1]
     is_active2 = stated.circle.is_active[ci.index2]
-    contacts = _circle_to_circle_impl(
+    return _circle_to_circle_impl(
         ci.shape1,
         ci.shape2,
         pos1,
         pos2,
         jnp.logical_and(is_active1, is_active2),
     )
-    return contacts, ci.shape1, ci.shape2
 
 
-def _circle_to_circle(
-    shaped: ShapeDict,
-    stated: StateDict,
-) -> tuple[Contact, Circle, Circle]:
-    ci = _circle_to_circle_index(shaped)
-    return _circle_to_circle_new(ci, stated)
-
-
-def _circle_to_static_circle(
-    shaped: ShapeDict,
-    stated: StateDict,
-) -> tuple[Contact, Circle, Circle]:
-    circle1 = jax.tree_map(
-        functools.partial(_pair_outer, reps=shaped.static_circle.mass.shape[0]),
-        shaped.circle,
-    )
-    circle2 = jax.tree_map(
-        functools.partial(_pair_inner, reps=shaped.circle.mass.shape[0]),
-        shaped.static_circle,
-    )
-    pos1, pos2 = tree_map2(generate_pairs, stated.circle.p, stated.static_circle.p)
-    is_active = jnp.logical_and(
-        *generate_pairs(stated.circle.is_active, stated.static_circle.is_active)
-    )
-    contacts = _circle_to_circle_impl(
-        circle1,
-        circle2,
+def _circle_to_static_circle(ci: ContactIndices, stated: StateDict) -> Contact:
+    pos1 = jax.tree_map(lambda arr: arr[ci.index1], stated.circle.p)
+    pos2 = jax.tree_map(lambda arr: arr[ci.index2], stated.static_circle.p)
+    is_active1 = stated.circle.is_active[ci.index1]
+    is_active2 = stated.static_circle.is_active[ci.index2]
+    return _circle_to_circle_impl(
+        ci.shape1,
+        ci.shape2,
         pos1,
         pos2,
-        is_active,
+        jnp.logical_and(is_active1, is_active2),
     )
-    return contacts, circle1, circle2
 
 
-def _capsule_to_circle(
-    shaped: ShapeDict,
-    stated: StateDict,
-) -> tuple[Contact, Capsule, Circle]:
-    capsule = jax.tree_map(
-        functools.partial(_pair_outer, reps=shaped.circle.mass.shape[0]),
-        shaped.capsule,
-    )
-    circle = jax.tree_map(
-        functools.partial(_pair_inner, reps=shaped.capsule.mass.shape[0]),
-        shaped.circle,
-    )
-    pos1, pos2 = tree_map2(generate_pairs, stated.capsule.p, stated.circle.p)
-    is_active = jnp.logical_and(
-        *generate_pairs(stated.capsule.is_active, stated.circle.is_active)
-    )
-    contacts = _capsule_to_circle_impl(
-        capsule,
-        circle,
+def _capsule_to_circle(ci: ContactIndices, stated: StateDict) -> Contact:
+    pos1 = jax.tree_map(lambda arr: arr[ci.index1], stated.capsule.p)
+    pos2 = jax.tree_map(lambda arr: arr[ci.index2], stated.circle.p)
+    is_active1 = stated.capsule.is_active[ci.index1]
+    is_active2 = stated.circle.is_active[ci.index2]
+    return _circle_to_circle_impl(
+        ci.shape1,
+        ci.shape2,
         pos1,
         pos2,
-        is_active,
+        jnp.logical_and(is_active1, is_active2),
     )
-    return contacts, capsule, circle
 
 
-def _segment_to_circle(
-    shaped: ShapeDict,
-    stated: StateDict,
-) -> tuple[Contact, Segment, Circle]:
-    segment = jax.tree_map(
-        functools.partial(_pair_outer, reps=shaped.circle.mass.shape[0]),
-        shaped.segment,
-    )
-    circle = jax.tree_map(
-        functools.partial(_pair_inner, reps=shaped.segment.mass.shape[0]),
-        shaped.circle,
-    )
-    pos1, pos2 = tree_map2(generate_pairs, stated.segment.p, stated.circle.p)
-    is_active = jnp.logical_and(
-        *generate_pairs(stated.segment.is_active, stated.circle.is_active)
-    )
-    contacts = _capsule_to_circle_impl(
-        segment.to_capsule(),
-        circle,
+def _segment_to_circle(ci: ContactIndices, stated: StateDict) -> Contact:
+    pos1 = jax.tree_map(lambda arr: arr[ci.index1], stated.segment.p)
+    pos2 = jax.tree_map(lambda arr: arr[ci.index2], stated.circle.p)
+    is_active1 = stated.segment.is_active[ci.index1]
+    is_active2 = stated.circle.is_active[ci.index2]
+    return _capsule_to_circle_impl(
+        ci.shape1.to_capsule(),
+        ci.shape2,
         pos1,
         pos2,
-        is_active,
+        jnp.logical_and(is_active1, is_active2),
     )
-    return contacts, segment, circle
-
-
-_CONTACT_INDEX_FUNCTIONS = {
-    ("circle", "circle"): _circle_to_circle,
-    ("circle", "static_circle"): _circle_to_static_circle,
-    ("capsule", "circle"): _capsule_to_circle,
-    ("segment", "circle"): _segment_to_circle,
-}
 
 
 _CONTACT_FUNCTIONS = {
@@ -655,12 +614,12 @@ def _segment_to_circle(
 
 
 @chex.dataclass
-class ContactWithMetadata:
+class ContactWithIndices:
     contact: Contact
     shape1: Shape
     shape2: Shape
-    outer_index: jax.Array
-    inner_index: jax.Array
+    index1: jax.Array
+    index2: jax.Array
 
     def gather_p_or_v(
         self,
@@ -668,10 +627,10 @@ def gather_p_or_v(
         inner: _PositionLike,
         orig: _PositionLike,
     ) -> _PositionLike:
-        xy_outer = jnp.zeros_like(orig.xy).at[self.outer_index].add(outer.xy)
-        angle_outer = jnp.zeros_like(orig.angle).at[self.outer_index].add(outer.angle)
-        xy_inner = jnp.zeros_like(orig.xy).at[self.inner_index].add(inner.xy)
-        angle_inner = jnp.zeros_like(orig.angle).at[self.inner_index].add(inner.angle)
+        xy_outer = jnp.zeros_like(orig.xy).at[self.index1].add(outer.xy)
+        angle_outer = jnp.zeros_like(orig.angle).at[self.index1].add(outer.angle)
+        xy_inner = jnp.zeros_like(orig.xy).at[self.index2].add(inner.xy)
+        angle_inner = jnp.zeros_like(orig.angle).at[self.index2].add(inner.angle)
         return orig.__class__(angle=angle_outer + angle_inner, xy=xy_outer + xy_inner)
 
 
@@ -691,38 +650,36 @@ class Space:
     bounce_threshold: float = 1.0
     max_velocity: float = 100.0
     max_angular_velocity: float = 100.0
-    contact_helpers: dict[tuple[str, str]] = dataclasses.field(
+    contact_indices: dict[tuple[str, str], ContactIndices] = dataclasses.field(
         default_factory=dict,
         init=False,
     )
 
     def __post_init__(self) -> None:
-        for (n1, n2), fn in _CONTACT_INDEX_FUNCTIONS.items():
+        for n1, n2 in _CONTACT_FUNCTIONS.keys():
             if self.shaped[n1] is not None and self.shaped[n2] is not None:
-                pass
+                if n1 == n2:
+                    ci = _self_ci(self.shaped[n1])
+                else:
+                    ci = _pair_ci(self.shaped[n1], self.shaped[n2])
+                self.contact_indices[n1, n2] = ci
 
-    def check_contacts(self, stated: StateDict) -> ContactWithMetadata:
+    def check_contacts(self, stated: StateDict) -> ContactWithIndices:
         contacts = []
         for (n1, n2), fn in _CONTACT_FUNCTIONS.items():
             if stated[n1] is not None and stated[n2] is not None:
-                contact, shape1, shape2 = fn(self.shaped, stated)
-                len1, len2 = stated[n1].p.batch_size(), stated[n2].p.batch_size()
+                ci = self.contact_indices[n1, n2]
+                contact = fn(ci, stated)
+                # Add some offset for global indices
                 offset1, offset2 = stated.offset(n1), stated.offset(n2)
-                if n1 == n2:
-                    outer_index, inner_index = generate_self_pairs(jnp.arange(len1))
-                else:
-                    outer_index, inner_index = generate_pairs(
-                        jnp.arange(len1),
-                        jnp.arange(len2),
-                    )
-                contact_with_meta = ContactWithMetadata(
+                contact_with_idx = ContactWithIndices(
                     contact=contact,
-                    shape1=shape1.to_shape(),
-                    shape2=shape2.to_shape(),
-                    outer_index=outer_index + offset1,
-                    inner_index=inner_index + offset2,
+                    shape1=ci.shape1.to_shape(),
+                    shape2=ci.shape2.to_shape(),
+                    index1=ci.index1 + offset1,
+                    index2=ci.index2 + offset2,
                 )
-                contacts.append(contact_with_meta)
+                contacts.append(contact_with_idx)
         return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *contacts)
 
     def n_possible_contacts(self) -> int:
@@ -994,10 +951,10 @@ def solve_constraints(
     solver: VelocitySolver,
     p: Position,
     v: Velocity,
-    contact_with_meta: ContactWithMetadata,
+    contact_with_idx: ContactWithIndices,
 ) -> tuple[Velocity, Position, VelocitySolver]:
     """Resolve collisions by Sequential Impulse method"""
-    outer, inner = contact_with_meta.outer_index, contact_with_meta.inner_index
+    outer, inner = contact_with_idx.index1, contact_with_idx.index2
 
     def get_pairs(p_or_v: _PositionLike) -> tuple[_PositionLike, _PositionLike]:
         return p_or_v.get_slice(outer), p_or_v.get_slice(inner)
@@ -1006,9 +963,9 @@ def get_pairs(p_or_v: _PositionLike) -> tuple[_PositionLike, _PositionLike]:
     v1, v2 = get_pairs(v)
     helper = init_contact_helper(
         space,
-        contact_with_meta.contact,
-        contact_with_meta.shape1,
-        contact_with_meta.shape2,
+        contact_with_idx.contact,
+        contact_with_idx.shape1,
+        contact_with_idx.shape2,
         p1,
         p2,
         v1,
@@ -1016,7 +973,7 @@ def get_pairs(p_or_v: _PositionLike) -> tuple[_PositionLike, _PositionLike]:
     )
     # Warm up the velocity solver
     solver = apply_initial_impulse(
-        contact_with_meta.contact,
+        contact_with_idx.contact,
         helper,
         solver.replace(v1=v1, v2=v2),
     )
@@ -1026,14 +983,14 @@ def vstep(
         vs: tuple[Velocity, VelocitySolver],
     ) -> tuple[Velocity, VelocitySolver]:
         v_i, solver_i = vs
-        solver_i1 = apply_velocity_normal(contact_with_meta.contact, helper, solver_i)
-        v_i1 = contact_with_meta.gather_p_or_v(solver_i1.v1, solver_i1.v2, v_i) + v_i
+        solver_i1 = apply_velocity_normal(contact_with_idx.contact, helper, solver_i)
+        v_i1 = contact_with_idx.gather_p_or_v(solver_i1.v1, solver_i1.v2, v_i) + v_i
         v1, v2 = get_pairs(v_i1)
         return v_i1, solver_i1.replace(v1=v1, v2=v2)
 
     v, solver = jax.lax.fori_loop(0, space.n_velocity_iter, vstep, (v, solver))
-    bv1, bv2 = apply_bounce(contact_with_meta.contact, helper, solver)
-    v = contact_with_meta.gather_p_or_v(bv1, bv2, v) + v
+    bv1, bv2 = apply_bounce(contact_with_idx.contact, helper, solver)
+    v = contact_with_idx.gather_p_or_v(bv1, bv2, v) + v
 
     def pstep(
         _n_iter: int,
@@ -1044,11 +1001,11 @@ def pstep(
             space.bias_factor,
             space.linear_slop,
             space.max_linear_correction,
-            contact_with_meta.contact,
+            contact_with_idx.contact,
             helper,
             solver_i,
         )
-        p_i1 = contact_with_meta.gather_p_or_v(solver_i1.p1, solver_i1.p2, p_i) + p_i
+        p_i1 = contact_with_idx.gather_p_or_v(solver_i1.p1, solver_i1.p2, p_i) + p_i
         p1, p2 = get_pairs(p_i1)
         return p_i1, solver_i1.replace(p1=p1, p2=p2)
 
@@ -1067,7 +1024,7 @@ def dont_solve_constraints(
     solver: VelocitySolver,
     p: Position,
     v: Velocity,
-    _contact_with_meta: ContactWithMetadata,
+    _contact_with_idx: ContactWithIndices,
 ) -> tuple[Velocity, Position, VelocitySolver]:
     return v, p, solver
 
@@ -1078,9 +1035,9 @@ def step(
     solver: VelocitySolver,
 ) -> tuple[StateDict, VelocitySolver]:
     state = update_velocity(space, space.shaped.concat(), stated.concat())
-    contact_with_meta = space.check_contacts(stated.update(state))
+    contact_with_idx = space.check_contacts(stated.update(state))
     # Check there's any penetration
-    contacts = contact_with_meta.contact.penetration >= 0
+    contacts = contact_with_idx.contact.penetration >= 0
     v, p, solver = jax.lax.cond(
         jnp.any(contacts),
         solve_constraints,
@@ -1089,7 +1046,7 @@ def step(
         solver.update(contacts),
         state.p,
         state.v,
-        contact_with_meta,
+        contact_with_idx,
     )
     statec = update_position(space, state.replace(v=v, p=p))
     return stated.update(statec), solver

From 18976133dd24828b6313ebc3a0f4b21a4651248b Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 26 Oct 2023 14:05:08 +0900
Subject: [PATCH 040/337] Use jit in _initialize_physics

---
 src/emevo/environments/circle_foraging.py | 42 +++++++++++++----------
 src/emevo/environments/phyjax2d.py        |  3 +-
 2 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 95e5731f..dda8b33e 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import functools
 import warnings
 from typing import Any, Callable, Literal, NamedTuple
 
@@ -256,6 +257,26 @@ def __init__(
         N = self._n_max_agents
         self._act_p1 = jnp.tile(jnp.array(act_p1), (N, 1))
         self._act_p2 = jnp.tile(jnp.array(act_p2), (N, 1))
+        self._place_agent = jax.jit(
+            functools.partial(
+                place_agent,
+                n_trial=self._max_place_attempts,
+                agent_radius=self._agent_radius,
+                coordinate=self._coordinate,
+                initloc_fn=self._agent_loc_fn,
+                shaped=self._physics.shaped,
+            )
+        )
+        self._place_food = jax.jit(
+            functools.partial(
+                place_food,
+                n_trial=self._max_place_attempts,
+                food_radius=self._food_radius,
+                coordinate=self._coordinate,
+                reprloc_fn=self._food_loc_fn,
+                shaped=self._physics.shaped,
+            )
+        )
 
     @staticmethod
     def _make_food_num_fn(
@@ -448,15 +469,7 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
         keys = jax.random.split(key, self._n_initial_foods + self._n_initial_agents)
         agent_failed = 0
         for i, key in enumerate(keys[: self._n_initial_agents]):
-            xy = place_agent(
-                n_trial=self._max_place_attempts,
-                agent_radius=self._agent_radius,
-                coordinate=self._coordinate,
-                initloc_fn=self._agent_loc_fn,
-                key=key,
-                shaped=self._physics.shaped,
-                stated=stated,
-            )
+            xy = self._place_agent(key=key, stated=stated)
             if jnp.all(xy < jnp.inf):
                 stated = stated.nested_replace(
                     "circle.p.xy",
@@ -471,16 +484,7 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
         food_failed = 0
         foodloc_state = self._initial_foodloc_state
         for i, key in enumerate(keys[self._n_initial_foods :]):
-            xy = place_food(
-                n_trial=self._max_place_attempts,
-                food_radius=self._food_radius,
-                coordinate=self._coordinate,
-                reprloc_fn=self._food_loc_fn,  # type: ignore
-                reprloc_state=foodloc_state,
-                key=key,
-                shaped=self._physics.shaped,
-                stated=stated,
-            )
+            xy = self._place_food(reprloc_state=foodloc_state, key=key, stated=stated)
             if jnp.all(xy < jnp.inf):
                 stated = stated.nested_replace(
                     "static_circle.p.xy",
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index ba2950ce..6bb5e42a 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -428,7 +428,7 @@ def _capsule_to_circle_impl(
     )
 
 
-@chex.dataclass
+@chex.dataclass(unsafe_hash=True)
 class StateDict:
     circle: State | None = None
     static_circle: State | None = None
@@ -471,6 +471,7 @@ def update(self, statec: State) -> Self:
             static_capsule=static_capsule,
         )
 
+    @functools.partial(jax.jit, static_argnums=(1,))
     def nested_replace(self, query: str, value: Any) -> Self:
         """Convenient method for nested replace"""
         queries = query.split(".")

From 4aa2e68a20c77672738a98bd0347a822c7358661 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 26 Oct 2023 16:49:38 +0900
Subject: [PATCH 041/337] Various fixes for moderngl_vis

---
 src/emevo/environments/circle_foraging.py | 17 ++-----
 src/emevo/environments/moderngl_vis.py    | 54 +++++++++++------------
 2 files changed, 31 insertions(+), 40 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index dda8b33e..6c927b38 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -155,9 +155,8 @@ def _make_physics(
     for _ in range(n_max_foods):
         builder.add_circle(
             radius=food_radius,
-            friction=0.0,
-            elasticity=0.2,
-            density=0.1,
+            friction=0.1,
+            elasticity=0.1,
             color=FOOD_COLOR,
             is_static=True,
         )
@@ -181,7 +180,7 @@ def __init__(
         n_agent_sensors: int = 8,
         sensor_length: float = 10.0,
         sensor_range: tuple[float, float] = (-120.0, 120.0),
-        agent_radius: float = 12.0,
+        agent_radius: float = 10.0,
         food_radius: float = 4.0,
         foodloc_interval: int = 1000,
         dt: float = 0.05,
@@ -367,15 +366,7 @@ def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool
             fill_value=-1,
         )
         index = index[0]
-        xy = place_agent(
-            n_trial=self._max_place_attempts,
-            agent_radius=self._agent_radius,
-            coordinate=self._coordinate,
-            initloc_fn=self._agent_loc_fn,
-            key=activate_key,
-            shaped=self._physics.shaped,
-            stated=state.physics,
-        )
+        xy = self._place_agent(key=key, stated=stated)
         ok = jnp.logical_and(index >= 0, jnp.all(xy < jnp.inf))
 
         def success() -> tuple[CFState, bool]:
diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index cc0213e0..3b8e01a7 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -41,7 +41,7 @@ class HasStateD(Protocol):
 void main() {
     float dist = length(gl_PointCoord.xy - vec2(0.5));
     float delta = fwidth(dist);
-    float alpha = smoothstep(0.45, 0.45 - delta, dist);
+    float alpha = smoothstep(0.5, 0.5 - delta, dist);
     f_color = v_color * alpha;
 }
 """
@@ -271,10 +271,15 @@ def _collect_static_lines(segment: Segment, state: State) -> NDArray:
     a, b = segment.get_ab()
     a = state.p.transform(a)
     b = state.p.transform(b)
-    for ai, bi in zip(a, b):
-        points.append(ai)
-        points.append(bi)
-    return np.array(points, dtype=np.float32)
+    return np.concatenate((a, b), axis=1).reshape(-1, 2)
+
+
+def _collect_heads(circle: Circle, state: State) -> NDArray:
+    y = np.array(circle.radius)
+    x = np.zeros_like(y)
+    p1, p2 = np.stack((x, y * 0.8), axis=1), np.stack((x, y * 1.2), axis=1)
+    p1, p2 = state.p.transform(p1), state.p.transform(p2)
+    return np.concatenate((p1, p2), axis=1).reshape(-1, 2)
 
 
 def _get_clip_ranges(lengthes: list[float]) -> list[tuple[float, float]]:
@@ -310,6 +315,7 @@ def __init__(
         self._screen_y = _get_clip_ranges([screen_height, *voffsets])
         self._x_range, self._y_range = x_range, y_range
         self._range_min = min(x_range, y_range)
+
         if x_range < y_range:
             self._range_min = x_range
             self._circle_scaling = screen_width / x_range * 2
@@ -337,7 +343,7 @@ def __init__(
         points, scales, colors = _collect_circles(
             space.shaped.static_circle,
             stated.static_circle,
-            self._circle_scaling ,
+            self._circle_scaling,
         )
         self._static_circles = CircleVA(
             ctx=context,
@@ -356,23 +362,20 @@ def __init__(
         self._static_lines = SegmentVA(
             ctx=context,
             program=static_segment_program,
-            segments=_collect_static_lines(
-                space.shaped.segment,
-                stated.segment,
-            ),
+            segments=_collect_static_lines(space.shaped.segment, stated.segment),
+        )
+        head_program = self._make_gl_program(
+            vertex_shader=_LINE_VERTEX_SHADER,
+            geometry_shader=_LINE_GEOMETRY_SHADER,
+            fragment_shader=_LINE_FRAGMENT_SHADER,
+            color=np.array([0.5, 0.0, 1.0, 1.0], dtype=np.float32),
+            width=np.array([0.004], dtype=np.float32),
+        )
+        self._heads = SegmentVA(
+            ctx=context,
+            program=head_program,
+            segments=_collect_heads(space.shaped.circle, stated.circle),
         )
-        # head_program = self._make_gl_program(
-        #     vertex_shader=_LINE_VERTEX_SHADER,
-        #     geometry_shader=_LINE_GEOMETRY_SHADER,
-        #     fragment_shader=_LINE_FRAGMENT_SHADER,
-        #     color=np.array([0.5, 0.0, 1.0, 1.0], dtype=np.float32),
-        #     width=np.array([0.004], dtype=np.float32),
-        # )
-        # self._heads = SegmentVA(
-        #     ctx=context,
-        #     program=head_program,
-        #     segments=_collect_heads(shapes),
-        # )
         self._overlays = {}
 
     def _make_gl_program(
@@ -454,11 +457,8 @@ def render(self, stated: StateDict) -> None:
         )
         if self._circles.update(*circles):
             self._circles.render()
-        # if self._heads.update(_collect_heads(shapes)):
-        #     self._heads.render()
-        # sensors = _collect_sensors(shapes)
-        # if self._sensors.update(sensors):
-        #     self._sensors.render()
+        if self._heads.update(_collect_heads(self._space.shaped.circle, stated.circle)):
+            self._heads.render()
         self._static_circles.render()
         self._static_lines.render()
 

From 16436336f061bc7d6e4f60f06424bf2aede6c130 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 26 Oct 2023 17:23:10 +0900
Subject: [PATCH 042/337] Measure average running time of step

---
 smoke-tests/circle_loop.py                | 12 +++++++++++-
 src/emevo/environments/circle_foraging.py |  2 +-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index a83f0729..bb67d140 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -1,9 +1,10 @@
 """Example of using circle foraging environment"""
 
-import chex
+import datetime
 import enum
 from typing import Any, Optional, Tuple
 
+import chex
 import jax
 import numpy as np
 import typer
@@ -68,8 +69,15 @@ def main(
     activate_index = n_agents
     jit_step = jax.jit(env.step)
     jit_sample = jax.jit(env.act_space.sample)
+    elapsed_list = []
     for i, key in tqdm(zip(range(steps), keys[1:])):
+        before = datetime.datetime.now()
         state = jit_step(state, jit_sample(key))
+        elapsed = datetime.datetime.now() - before
+        if i == 0:
+            print(f"Compile: {elapsed.total_seconds()}s")
+        elif i > 10:
+            elapsed_list.append(elapsed / datetime.timedelta(microseconds=1))
         if replace and i % 1000 == 0:
             if n_agents + 5 <= activate_index:
                 state, success = env.deactivate(state, activate_index)
@@ -88,6 +96,8 @@ def main(
             visualizer.render(state)
             visualizer.show()
 
+    print(f"Avg. μs for step: {np.mean(elapsed_list)}")
+
 
 if __name__ == "__main__":
     typer.run(main)
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 6c927b38..5a3c11dc 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -149,7 +149,7 @@ def _make_physics(
             radius=agent_radius,
             friction=0.1,
             elasticity=0.2,
-            density=0.01,
+            density=0.04,
             color=AGENT_COLOR,
         )
     for _ in range(n_max_foods):

From 650edd86b67f5844cfd77b4d1e1b0ad1c37ea678 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 27 Oct 2023 14:43:20 +0900
Subject: [PATCH 043/337] Use nstep

---
 src/emevo/environments/circle_foraging.py | 15 +++++++++---
 src/emevo/environments/phyjax2d.py        | 30 +++++++++++++++++++----
 2 files changed, 36 insertions(+), 9 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 5a3c11dc..bd77b640 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -14,7 +14,7 @@
 from emevo.environments.phyjax2d import Position
 from emevo.environments.phyjax2d import Space as Physics
 from emevo.environments.phyjax2d import State, StateDict, Velocity, VelocitySolver
-from emevo.environments.phyjax2d import step as physics_step
+from emevo.environments.phyjax2d import nstep as physics_nstep
 from emevo.environments.phyjax2d_utils import (
     Color,
     SpaceBuilder,
@@ -188,7 +188,7 @@ def __init__(
         angular_damping: float = 0.8,
         n_velocity_iter: int = 6,
         n_position_iter: int = 2,
-        n_physics_steps: int = 5,
+        n_physics_iter: int = 5,
         max_place_attempts: int = 10,
     ) -> None:
         # Coordinate and range
@@ -236,7 +236,7 @@ def __init__(
         )
         self._agent_indices = jnp.arange(n_max_agents)
         self._food_indices = jnp.arange(n_max_foods)
-        self._n_physics_steps = n_physics_steps
+        self._n_physics_iter = n_physics_iter
         # Spaces
         N = self._n_max_agents
         self.act_space = BoxSpace(low=0.0, high=MAX_FORCE, shape=(N, 2))
@@ -347,6 +347,7 @@ def set_agent_loc_fn(self, agent_loc_fn: str | tuple | InitLocFn) -> None:
         self._agent_loc_fn = self._make_agent_loc_fn(agent_loc_fn)
 
     def step(self, state: CFState, action: ArrayLike) -> CFState:
+        # Add force
         act = self.act_space.clip(jnp.array(action))
         f1, f2 = act[:, 0], act[:, 1]
         f1 = jnp.stack((jnp.zeros_like(f1), f1), axis=1) * -self._act_p1
@@ -355,7 +356,13 @@ def step(self, state: CFState, action: ArrayLike) -> CFState:
         circle = circle.apply_force_local(self._act_p1, f1)
         circle = circle.apply_force_local(self._act_p2, f2)
         stated = state.physics.replace(circle=circle)
-        stated, solver = physics_step(self._physics, stated, state.solver)
+        # Step physics simulator
+        stated, solver = physics_nstep(
+            self._n_physics_iter,
+            self._physics,
+            stated,
+            state.solver,
+        )
         return state.replace(physics=stated, solver=solver)
 
     def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 6bb5e42a..908a01b0 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -229,7 +229,12 @@ class State(PyTreeOps):
     @staticmethod
     def from_position(p: Position) -> Self:
         n = p.batch_size()
-        return State(p=p, v=Velocity.zeros(n), f=Force.zeros(n), is_active=jnp.ones(n))
+        return State(
+            p=p,
+            v=Velocity.zeros(n),
+            f=Force.zeros(n),
+            is_active=jnp.ones(n, dtype=bool),
+        )
 
     @staticmethod
     def zeros(n: int) -> Self:
@@ -237,7 +242,7 @@ def zeros(n: int) -> Self:
             p=Position.zeros(n),
             v=Velocity.zeros(n),
             f=Force.zeros(n),
-            is_active=jnp.ones(n),
+            is_active=jnp.ones(n, dtype=bool),
         )
 
     def apply_force_global(self, point: jax.Array, force: jax.Array) -> Self:
@@ -428,7 +433,7 @@ def _capsule_to_circle_impl(
     )
 
 
-@chex.dataclass(unsafe_hash=True)
+@chex.dataclass
 class StateDict:
     circle: State | None = None
     static_circle: State | None = None
@@ -1049,8 +1054,23 @@ def step(
         state.v,
         contact_with_idx,
     )
-    statec = update_position(space, state.replace(v=v, p=p))
-    return stated.update(statec), solver
+    state = update_position(space, state.replace(v=v, p=p))
+    return stated.update(state), solver
+
+
+def nstep(
+    n: int,
+    space: Space,
+    stated: StateDict,
+    solver: VelocitySolver,
+) -> tuple[StateDict, VelocitySolver]:
+    def wrapped_step(
+        _n_iter: int,
+        stated_and_solver: tuple[StateDict, VelocitySolver],
+    ) -> tuple[StateDict, VelocitySolver]:
+        return step(space, *stated_and_solver)
+
+    return jax.lax.fori_loop(0, n, wrapped_step, (stated, solver))
 
 
 @chex.dataclass

From 3823061032b6512d92a56591646746babd4bc35f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 28 Oct 2023 00:59:55 +0900
Subject: [PATCH 044/337] Optimizations on phyjax2d

---
 src/emevo/environments/phyjax2d.py | 53 ++++++++++++------------------
 1 file changed, 21 insertions(+), 32 deletions(-)

diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 908a01b0..add16b5b 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -18,16 +18,9 @@ def then(x: Any, f: Callable[[Any], Any]) -> Any:
         return f(x)
 
 
-def safe_norm(x: jax.Array, axis: Axis | None = None) -> jax.Array:
-    is_zero = jnp.allclose(x, 0.0)
-    x = jnp.where(is_zero, jnp.ones_like(x), x)
-    n = jnp.linalg.norm(x, axis=axis)
-    return jnp.where(is_zero, 0.0, n)  # pyright: ignore
-
-
 def normalize(x: jax.Array, axis: Axis | None = None) -> tuple[jax.Array, jax.Array]:
-    norm = safe_norm(x, axis=axis)
-    n = x / (norm + 1e-6 * (norm == 0.0))
+    norm = jnp.linalg.norm(x, axis=axis)
+    n = x / jnp.clip(norm, a_min=1e-6)
     return n, norm
 
 
@@ -627,18 +620,6 @@ class ContactWithIndices:
     index1: jax.Array
     index2: jax.Array
 
-    def gather_p_or_v(
-        self,
-        outer: _PositionLike,
-        inner: _PositionLike,
-        orig: _PositionLike,
-    ) -> _PositionLike:
-        xy_outer = jnp.zeros_like(orig.xy).at[self.index1].add(outer.xy)
-        angle_outer = jnp.zeros_like(orig.angle).at[self.index1].add(outer.angle)
-        xy_inner = jnp.zeros_like(orig.xy).at[self.index2].add(inner.xy)
-        angle_inner = jnp.zeros_like(orig.angle).at[self.index2].add(inner.angle)
-        return orig.__class__(angle=angle_outer + angle_inner, xy=xy_outer + xy_inner)
-
 
 @chex.dataclass
 class Space:
@@ -960,13 +941,23 @@ def solve_constraints(
     contact_with_idx: ContactWithIndices,
 ) -> tuple[Velocity, Position, VelocitySolver]:
     """Resolve collisions by Sequential Impulse method"""
-    outer, inner = contact_with_idx.index1, contact_with_idx.index2
-
-    def get_pairs(p_or_v: _PositionLike) -> tuple[_PositionLike, _PositionLike]:
-        return p_or_v.get_slice(outer), p_or_v.get_slice(inner)
+    idx1, idx2 = contact_with_idx.index1, contact_with_idx.index2
 
-    p1, p2 = get_pairs(p)
-    v1, v2 = get_pairs(v)
+    def gather_and_pair(
+        a: _PositionLike,
+        b: _PositionLike,
+        orig: _PositionLike,
+    ) -> tuple[_PositionLike, _PositionLike, _PositionLike]:
+        xy0, angle0 = jnp.zeros_like(orig.xy), jnp.zeros_like(orig.angle)
+        xy = xy0.at[idx1].add(a.xy).at[idx2].add(b.xy) + orig.xy
+        angle = angle0.at[idx1].add(a.angle).at[idx2].add(b.angle) + orig.angle
+        cls = orig.__class__
+        a = cls(angle=angle[idx1], xy=xy[idx1])
+        b = cls(angle=angle[idx2], xy=xy[idx2])
+        return cls(angle=angle, xy=xy), a, b
+
+    p1, p2 = p.get_slice(idx1), p.get_slice(idx2)
+    v1, v2 = v.get_slice(idx1), v.get_slice(idx2)
     helper = init_contact_helper(
         space,
         contact_with_idx.contact,
@@ -990,13 +981,12 @@ def vstep(
     ) -> tuple[Velocity, VelocitySolver]:
         v_i, solver_i = vs
         solver_i1 = apply_velocity_normal(contact_with_idx.contact, helper, solver_i)
-        v_i1 = contact_with_idx.gather_p_or_v(solver_i1.v1, solver_i1.v2, v_i) + v_i
-        v1, v2 = get_pairs(v_i1)
+        v_i1, v1, v2 = gather_and_pair(solver_i1.v1, solver_i1.v2, v_i)
         return v_i1, solver_i1.replace(v1=v1, v2=v2)
 
     v, solver = jax.lax.fori_loop(0, space.n_velocity_iter, vstep, (v, solver))
     bv1, bv2 = apply_bounce(contact_with_idx.contact, helper, solver)
-    v = contact_with_idx.gather_p_or_v(bv1, bv2, v) + v
+    v = gather_and_pair(bv1, bv2, v)[0]
 
     def pstep(
         _n_iter: int,
@@ -1011,8 +1001,7 @@ def pstep(
             helper,
             solver_i,
         )
-        p_i1 = contact_with_idx.gather_p_or_v(solver_i1.p1, solver_i1.p2, p_i) + p_i
-        p1, p2 = get_pairs(p_i1)
+        p_i1, p1, p2 = gather_and_pair(solver_i1.p1, solver_i1.p2, p_i)
         return p_i1, solver_i1.replace(p1=p1, p2=p2)
 
     pos_solver = PositionSolver(

From b30bf4c726bdd72bd7bc61bff090dec802dc8b9e Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 28 Oct 2023 02:07:31 +0900
Subject: [PATCH 045/337] Misc

---
 src/emevo/environments/circle_foraging.py |  4 ++--
 src/emevo/environments/phyjax2d_utils.py  | 12 ++++++++++++
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index bd77b640..5f8ce8f1 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -183,7 +183,7 @@ def __init__(
         agent_radius: float = 10.0,
         food_radius: float = 4.0,
         foodloc_interval: int = 1000,
-        dt: float = 0.05,
+        dt: float = 0.1,
         linear_damping: float = 0.9,
         angular_damping: float = 0.8,
         n_velocity_iter: int = 6,
@@ -373,7 +373,7 @@ def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool
             fill_value=-1,
         )
         index = index[0]
-        xy = self._place_agent(key=key, stated=stated)
+        xy = self._place_agent(key=key, stated=state.physics)
         ok = jnp.logical_and(index >= 0, jnp.all(xy < jnp.inf))
 
         def success() -> tuple[CFState, bool]:
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 294dedee..2c2b8b58 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -13,9 +13,12 @@
     Shape,
     ShapeDict,
     Space,
+    State,
     StateDict,
     _length_to_points,
     _vmap_dot,
+    circle_raycast,
+    segment_raycast,
 )
 from emevo.vec2d import Vec2d, Vec2dLike
 
@@ -328,3 +331,12 @@ def circle_overwrap(
         overwrap2seg = jnp.array(False)
 
     return jnp.logical_or(overwrap2cir, overwrap2seg)
+
+
+def raycast_closest(
+    p1: jax.Array,
+    p2: jax.Array,
+    shaped: ShapeDict,
+    stated: StateDict,
+):
+    pass

From f275505971465380e9c292ccafd8d480c8d106ab Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 28 Oct 2023 11:33:36 +0900
Subject: [PATCH 046/337] Start implementing obs

---
 src/emevo/environments/phyjax2d.py       |  5 ++---
 src/emevo/environments/phyjax2d_utils.py | 16 ++++++++++++++--
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index add16b5b..7896e07a 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -948,9 +948,8 @@ def gather_and_pair(
         b: _PositionLike,
         orig: _PositionLike,
     ) -> tuple[_PositionLike, _PositionLike, _PositionLike]:
-        xy0, angle0 = jnp.zeros_like(orig.xy), jnp.zeros_like(orig.angle)
-        xy = xy0.at[idx1].add(a.xy).at[idx2].add(b.xy) + orig.xy
-        angle = angle0.at[idx1].add(a.angle).at[idx2].add(b.angle) + orig.angle
+        xy = orig.xy.at[idx1].add(a.xy).at[idx2].add(b.xy)
+        angle = orig.angle.at[idx1].add(a.angle).at[idx2].add(b.angle)
         cls = orig.__class__
         a = cls(angle=angle[idx1], xy=xy[idx1])
         b = cls(angle=angle[idx2], xy=xy[idx2])
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 2c2b8b58..6a09186f 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -301,7 +301,7 @@ def circle_overwrap(
     else:
         overwrap2cir = jnp.array(False)
 
-     # Circle-static_circle overwrap
+    # Circle-static_circle overwrap
     if stated.static_circle is not None and shaped.static_circle is not None:
         cpos = stated.static_circle.p.xy
         # Suppose that cpos.shape == (N, 2) and xy.shape == (2,)
@@ -339,4 +339,16 @@ def raycast_closest(
     shaped: ShapeDict,
     stated: StateDict,
 ):
-    pass
+    if shaped.circle is not None:
+        rc = circle_raycast(0.0, 1.0, p1, p2, shaped.circle, stated.circle)
+    if shaped.static_circle is not None:
+        rc = circle_raycast(
+            0.0,
+            1.0,
+            p1,
+            p2,
+            shaped.static_circle,
+            stated.static_circle,
+        )
+    if shaped.segment is not None:
+        rc = segment_raycast(1.0, p1, p2, shaped.segment, stated.segment)

From 6e617df41edf99a9ab983a645f4182058e831830 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 28 Oct 2023 16:58:32 +0900
Subject: [PATCH 047/337] Some more microoptimizations

---
 src/emevo/environments/circle_foraging.py |   3 +-
 src/emevo/environments/phyjax2d.py        | 123 +++++++++++-----------
 2 files changed, 61 insertions(+), 65 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 5f8ce8f1..3711427d 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -276,6 +276,7 @@ def __init__(
                 shaped=self._physics.shaped,
             )
         )
+        self._nstep = jax.jit(physics_nstep, static_argnums=(0, 1))
 
     @staticmethod
     def _make_food_num_fn(
@@ -357,7 +358,7 @@ def step(self, state: CFState, action: ArrayLike) -> CFState:
         circle = circle.apply_force_local(self._act_p2, f2)
         stated = state.physics.replace(circle=circle)
         # Step physics simulator
-        stated, solver = physics_nstep(
+        stated, solver = self._nstep(
             self._n_physics_iter,
             self._physics,
             stated,
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 7896e07a..28c40974 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -1,5 +1,6 @@
 import dataclasses
 import functools
+import uuid
 from collections.abc import Sequence
 from typing import Any, Callable, Protocol
 
@@ -187,6 +188,9 @@ class Shape(PyTreeOps):
     friction: jax.Array
     rgba: jax.Array
 
+    def batch_size(self) -> int:
+        return self.mass.shape[0]
+
     def inv_mass(self) -> jax.Array:
         """To support static shape, set let inv_mass 0 if mass is infinite"""
         m = self.mass
@@ -250,6 +254,9 @@ def apply_force_local(self, point: jax.Array, force: jax.Array) -> Self:
         point = self.p.transform(point)
         return self.apply_force_global(point, force)
 
+    def batch_size(self) -> int:
+        return self.p.batch_size()
+
 
 @chex.dataclass
 class Contact(PyTreeOps):
@@ -426,6 +433,9 @@ def _capsule_to_circle_impl(
     )
 
 
+_ALL_SHAPES = ["circle", "static_circle", "capsule", "static_capsule", "segment"]
+
+
 @chex.dataclass
 class StateDict:
     circle: State | None = None
@@ -438,20 +448,11 @@ def concat(self) -> Self:
         states = [s for s in self.values() if s is not None]
         return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *states)
 
-    def offset(self, key: str) -> int:
-        total = 0
-        for k, state in self.items():
-            if k == key:
-                return total
-            if state is not None:
-                total += state.p.batch_size()
-        raise RuntimeError("Unreachable")
-
     def _get(self, name: str, state: State) -> State | None:
         if self[name] is None:
             return None
         else:
-            start = self.offset(name)
+            start = _offset(self, name)
             end = start + self[name].p.batch_size()
             return state.get_slice(jnp.arange(start, end))
 
@@ -509,6 +510,17 @@ def zeros_state(self) -> StateDict:
         )
 
 
+def _offset(sd: ShapeDict | StateDict, name: str) -> int:
+    total = 0
+    for key in _ALL_SHAPES:
+        if key == name:
+            return total
+        s = sd[key]
+        if s is not None:
+            total += s.batch_size()
+    raise RuntimeError("Unreachable")
+
+
 @chex.dataclass
 class ContactIndices:
     shape1: Shape
@@ -612,15 +624,6 @@ def _segment_to_circle(ci: ContactIndices, stated: StateDict) -> Contact:
 }
 
 
-@chex.dataclass
-class ContactWithIndices:
-    contact: Contact
-    shape1: Shape
-    shape2: Shape
-    index1: jax.Array
-    index2: jax.Array
-
-
 @chex.dataclass
 class Space:
     gravity: jax.Array
@@ -637,36 +640,47 @@ class Space:
     bounce_threshold: float = 1.0
     max_velocity: float = 100.0
     max_angular_velocity: float = 100.0
-    contact_indices: dict[tuple[str, str], ContactIndices] = dataclasses.field(
+    _ci: dict[tuple[str, str], ContactIndices] = dataclasses.field(
         default_factory=dict,
         init=False,
     )
+    _ci_total: ContactIndices | None = dataclasses.field(default=None, init=False)
+    _hash_key: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4, init=False)
+
+    def __hash__(self) -> int:
+        return hash(self._hash_key)
+
+    def __eq__(self, other: Any) -> int:
+        return self._hash_key == other._hash_key
 
     def __post_init__(self) -> None:
+        ci_slided_list = []
         for n1, n2 in _CONTACT_FUNCTIONS.keys():
             if self.shaped[n1] is not None and self.shaped[n2] is not None:
                 if n1 == n2:
                     ci = _self_ci(self.shaped[n1])
                 else:
                     ci = _pair_ci(self.shaped[n1], self.shaped[n2])
-                self.contact_indices[n1, n2] = ci
-
-    def check_contacts(self, stated: StateDict) -> ContactWithIndices:
-        contacts = []
-        for (n1, n2), fn in _CONTACT_FUNCTIONS.items():
-            if stated[n1] is not None and stated[n2] is not None:
-                ci = self.contact_indices[n1, n2]
-                contact = fn(ci, stated)
+                self._ci[n1, n2] = ci
+                offset1, offset2 = _offset(self.shaped, n1), _offset(self.shaped, n2)
                 # Add some offset for global indices
-                offset1, offset2 = stated.offset(n1), stated.offset(n2)
-                contact_with_idx = ContactWithIndices(
-                    contact=contact,
+                ci_slided = ContactIndices(
                     shape1=ci.shape1.to_shape(),
                     shape2=ci.shape2.to_shape(),
                     index1=ci.index1 + offset1,
                     index2=ci.index2 + offset2,
                 )
-                contacts.append(contact_with_idx)
+                ci_slided_list.append(ci_slided)
+        self._ci_total = jax.tree_map(
+            lambda *args: jnp.concatenate(args, axis=0),
+            *ci_slided_list,
+        )
+
+    def check_contacts(self, stated: StateDict) -> Contact:
+        contacts = []
+        for (n1, n2), fn in _CONTACT_FUNCTIONS.items():
+            if stated[n1] is not None and stated[n2] is not None:
+                contacts.append(fn(self._ci[n1, n2], stated))
         return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *contacts)
 
     def n_possible_contacts(self) -> int:
@@ -938,10 +952,10 @@ def solve_constraints(
     solver: VelocitySolver,
     p: Position,
     v: Velocity,
-    contact_with_idx: ContactWithIndices,
+    contact: Contact,
 ) -> tuple[Velocity, Position, VelocitySolver]:
     """Resolve collisions by Sequential Impulse method"""
-    idx1, idx2 = contact_with_idx.index1, contact_with_idx.index2
+    idx1, idx2 = space._ci_total.index1, space._ci_total.index2
 
     def gather_and_pair(
         a: _PositionLike,
@@ -959,32 +973,28 @@ def gather_and_pair(
     v1, v2 = v.get_slice(idx1), v.get_slice(idx2)
     helper = init_contact_helper(
         space,
-        contact_with_idx.contact,
-        contact_with_idx.shape1,
-        contact_with_idx.shape2,
+        contact,
+        space._ci_total.shape1,
+        space._ci_total.shape2,
         p1,
         p2,
         v1,
         v2,
     )
     # Warm up the velocity solver
-    solver = apply_initial_impulse(
-        contact_with_idx.contact,
-        helper,
-        solver.replace(v1=v1, v2=v2),
-    )
+    solver = apply_initial_impulse(contact, helper, solver.replace(v1=v1, v2=v2))
 
     def vstep(
         _n_iter: int,
         vs: tuple[Velocity, VelocitySolver],
     ) -> tuple[Velocity, VelocitySolver]:
         v_i, solver_i = vs
-        solver_i1 = apply_velocity_normal(contact_with_idx.contact, helper, solver_i)
+        solver_i1 = apply_velocity_normal(contact, helper, solver_i)
         v_i1, v1, v2 = gather_and_pair(solver_i1.v1, solver_i1.v2, v_i)
         return v_i1, solver_i1.replace(v1=v1, v2=v2)
 
     v, solver = jax.lax.fori_loop(0, space.n_velocity_iter, vstep, (v, solver))
-    bv1, bv2 = apply_bounce(contact_with_idx.contact, helper, solver)
+    bv1, bv2 = apply_bounce(contact, helper, solver)
     v = gather_and_pair(bv1, bv2, v)[0]
 
     def pstep(
@@ -996,7 +1006,7 @@ def pstep(
             space.bias_factor,
             space.linear_slop,
             space.max_linear_correction,
-            contact_with_idx.contact,
+            contact,
             helper,
             solver_i,
         )
@@ -1013,34 +1023,19 @@ def pstep(
     return v, p, solver
 
 
-def dont_solve_constraints(
-    _space: Space,
-    solver: VelocitySolver,
-    p: Position,
-    v: Velocity,
-    _contact_with_idx: ContactWithIndices,
-) -> tuple[Velocity, Position, VelocitySolver]:
-    return v, p, solver
-
-
 def step(
     space: Space,
     stated: StateDict,
     solver: VelocitySolver,
 ) -> tuple[StateDict, VelocitySolver]:
     state = update_velocity(space, space.shaped.concat(), stated.concat())
-    contact_with_idx = space.check_contacts(stated.update(state))
-    # Check there's any penetration
-    contacts = contact_with_idx.contact.penetration >= 0
-    v, p, solver = jax.lax.cond(
-        jnp.any(contacts),
-        solve_constraints,
-        dont_solve_constraints,
+    contact = space.check_contacts(stated.update(state))
+    v, p, solver = solve_constraints(
         space,
-        solver.update(contacts),
+        solver.update(contact.penetration >= 0),
         state.p,
         state.v,
-        contact_with_idx,
+        contact,
     )
     state = update_position(space, state.replace(v=v, p=p))
     return stated.update(state), solver

From 2f107087148792326a30b68ce08f92a771cdc658 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 30 Oct 2023 00:57:13 +0900
Subject: [PATCH 048/337] Refactor

---
 src/emevo/environments/phyjax2d.py       | 23 +++++++++--------------
 src/emevo/environments/phyjax2d_utils.py |  8 +++++---
 2 files changed, 14 insertions(+), 17 deletions(-)

diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 28c40974..510b6e85 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -193,13 +193,11 @@ def batch_size(self) -> int:
 
     def inv_mass(self) -> jax.Array:
         """To support static shape, set let inv_mass 0 if mass is infinite"""
-        m = self.mass
-        return jnp.where(jnp.isfinite(m), 1.0 / m, jnp.zeros_like(m))
+        return jnp.where(jnp.isfinite(self.mass), 1.0 / self.mass, 0.0)
 
     def inv_moment(self) -> jax.Array:
         """As inv_mass does, set inv_moment 0 if moment is infinite"""
-        m = self.moment
-        return jnp.where(jnp.isfinite(m), 1.0 / m, jnp.zeros_like(m))
+        return jnp.where(jnp.isfinite(self.moment), 1.0 / self.moment, 0.0)
 
     def to_shape(self) -> Self:
         return Shape(
@@ -322,8 +320,8 @@ class VelocitySolver:
 
     def update(self, new_contact: jax.Array) -> Self:
         continuing_contact = jnp.logical_and(self.contact, new_contact)
-        pn = jnp.where(continuing_contact, self.pn, jnp.zeros_like(self.pn))
-        pt = jnp.where(continuing_contact, self.pt, jnp.zeros_like(self.pt))
+        pn = jnp.where(continuing_contact, self.pn, 0.0)
+        pt = jnp.where(continuing_contact, self.pt, 0.0)
         return self.replace(pn=pn, pt=pt, contact=new_contact)
 
 
@@ -848,7 +846,7 @@ def apply_velocity_normal(
     )
     # Filter dv
     dv1, dv2 = jax.tree_map(
-        lambda x: jnp.where(solver.contact, x, jnp.zeros_like(x)),
+        lambda x: jnp.where(solver.contact, x, 0.0),
         (dvn1 + dvt1, dvn2 + dvt2),
     )
     # Summing up dv per each contact pair
@@ -887,10 +885,7 @@ def apply_bounce(
     )
     # Filter dv
     allow_bounce = jnp.logical_and(solver.contact, helper.allow_bounce)
-    return jax.tree_map(
-        lambda x: jnp.where(allow_bounce, x, jnp.zeros_like(x)),
-        (dv1, dv2),
-    )
+    return jax.tree_map(lambda x: jnp.where(allow_bounce, x, 0.0), (dv1, dv2))
 
 
 @chex.dataclass
@@ -928,7 +923,7 @@ def correct_position(
     kn1 = _effective_mass(helper.inv_mass1, helper.inv_moment1, r1, contact.normal)
     kn2 = _effective_mass(helper.inv_mass2, helper.inv_moment2, r2, contact.normal)
     k_normal = kn1 + kn2
-    impulse = jnp.where(k_normal > 0.0, -c / k_normal, jnp.zeros_like(c))
+    impulse = jnp.where(k_normal > 0.0, -c / k_normal, 0.0)
     pn = impulse * contact.normal
     p1 = Position(
         angle=-helper.inv_moment1 * jnp.cross(r1, pn),
@@ -941,7 +936,7 @@ def correct_position(
     min_sep = jnp.fmin(solver.min_separation, separation)
     # Filter separation
     p1, p2 = jax.tree_map(
-        lambda x: jnp.where(solver.contact, x, jnp.zeros_like(x)),
+        lambda x: jnp.where(solver.contact, x, 0.0),
         (p1, p2),
     )
     return solver.replace(p1=p1, p2=p2, min_separation=min_sep)
@@ -995,7 +990,7 @@ def vstep(
 
     v, solver = jax.lax.fori_loop(0, space.n_velocity_iter, vstep, (v, solver))
     bv1, bv2 = apply_bounce(contact, helper, solver)
-    v = gather_and_pair(bv1, bv2, v)[0]
+    v, _, _ = gather_and_pair(bv1, bv2, v)
 
     def pstep(
         _n_iter: int,
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 6a09186f..22479e9f 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -334,21 +334,23 @@ def circle_overwrap(
 
 
 def raycast_closest(
+    fraction: float,
     p1: jax.Array,
     p2: jax.Array,
     shaped: ShapeDict,
     stated: StateDict,
 ):
     if shaped.circle is not None:
-        rc = circle_raycast(0.0, 1.0, p1, p2, shaped.circle, stated.circle)
+        rc = circle_raycast(0.0, fraction, p1, p2, shaped.circle, stated.circle)
+        jnp.where(rc.hit, rc.fraction, 0.0)
     if shaped.static_circle is not None:
         rc = circle_raycast(
             0.0,
-            1.0,
+            fraction,
             p1,
             p2,
             shaped.static_circle,
             stated.static_circle,
         )
     if shaped.segment is not None:
-        rc = segment_raycast(1.0, p1, p2, shaped.segment, stated.segment)
+        rc = segment_raycast(fraction, p1, p2, shaped.segment, stated.segment)

From 6bbbc46fb705ca3f2e056a92b8c09f19ff09908e Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 30 Oct 2023 14:42:05 +0900
Subject: [PATCH 049/337] Use axy array to reduce scatter op

---
 src/emevo/environments/phyjax2d.py | 144 +++++++++++++++--------------
 1 file changed, 77 insertions(+), 67 deletions(-)

diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 510b6e85..c5a14c2d 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -121,6 +121,10 @@ def shape(self) -> Any:
 TWO_PI = jnp.pi * 2
 
 
+def _axy(angle: jax.Array, xy: jax.Array) -> jax.Array:
+    return jnp.concatenate((jnp.expand_dims(angle, axis=-1), xy), axis=-1)
+
+
 class _PositionLike(Protocol):
     angle: jax.Array  # Angular velocity (N,)
     xy: jax.Array  # (N, 2)
@@ -131,16 +135,29 @@ def __init__(self, angle: jax.Array, xy: jax.Array) -> None:
     def batch_size(self) -> int:
         return self.angle.shape[0]
 
+    def into_axy(self) -> jax.Array:
+        return _axy(self.angle, self.xy)
+
     @classmethod
     def zeros(cls: type[Self], n: int) -> Self:
         return cls(angle=jnp.zeros((n,)), xy=jnp.zeros((n, 2)))
 
+    @classmethod
+    def from_axy(cls: type[Self], axy: int) -> Self:
+        angle = jax.lax.squeeze(jax.lax.slice_in_dim(axy, 0, 1, axis=-1), (-1,))
+        xy = jax.lax.slice_in_dim(axy, 1, 3, axis=-1)
+        return cls(angle=angle, xy=xy)
+
 
 @chex.dataclass
 class Velocity(_PositionLike, PyTreeOps):
     angle: jax.Array  # Angular velocity (N,)
     xy: jax.Array  # (N, 2)
 
+    def rv(self, r: jax.Array) -> jax.Array:
+        """Relative velocity"""
+        return self.xy + _sv_cross(self.angle, r)
+
 
 @chex.dataclass
 class Force(_PositionLike, PyTreeOps):
@@ -312,8 +329,8 @@ class ContactHelper:
 
 @chex.dataclass
 class VelocitySolver:
-    v1: Velocity
-    v2: Velocity
+    v1: jax.Array
+    v2: jax.Array
     pn: jax.Array
     pt: jax.Array
     contact: jax.Array
@@ -340,13 +357,6 @@ def _sv_cross(s: jax.Array, v: jax.Array) -> jax.Array:
     return jnp.stack((y * -s, x * s), axis=-1)
 
 
-def _dv2from1(v1: Velocity, r1: jax.Array, v2: Velocity, r2: jax.Array) -> jax.Array:
-    """Compute relative veclotiy from v2/r2 to v1/r1"""
-    rel_v1 = v1.xy + _sv_cross(v1.angle, r1)
-    rel_v2 = v2.xy + _sv_cross(v2.angle, r2)
-    return rel_v2 - rel_v1
-
-
 def _effective_mass(
     inv_mass: jax.Array,
     inv_moment: jax.Array,
@@ -695,8 +705,8 @@ def n_possible_contacts(self) -> int:
     def init_solver(self) -> VelocitySolver:
         n = self.n_possible_contacts()
         return VelocitySolver(
-            v1=Velocity.zeros(n),
-            v2=Velocity.zeros(n),
+            v1=jnp.zeros((n, 3)),
+            v2=jnp.zeros((n, 3)),
             pn=jnp.zeros(n),
             pt=jnp.zeros(n),
             contact=jnp.zeros(n, dtype=bool),
@@ -762,7 +772,7 @@ def init_contact_helper(
     # k_normal, k_tangent, and v_bias should have (N(N-1)/2, N_contacts) shape
     chex.assert_equal_shape((contact.friction, kn1, kn2, kt1, kt2, v_bias))
     # Compute elasiticity * relative_vel
-    dv = _dv2from1(v1, r1, v2, r2)
+    dv = v2.rv(r2) - v1.rv(r1)
     vn = _vmap_dot(dv, contact.normal)
     return ContactHelper(  # type: ignore
         tangent=tangent,
@@ -790,17 +800,21 @@ def apply_initial_impulse(
 ) -> VelocitySolver:
     """Warm starting by applying initial impulse"""
     p = helper.tangent * solver.pt + contact.normal * solver.pn
-    v1 = solver.v1 - Velocity(
+    v1 = solver.v1 - _axy(
         angle=helper.inv_moment1 * jnp.cross(helper.r1, p),
         xy=p * helper.inv_mass1,
     )
-    v2 = solver.v2 + Velocity(
+    v2 = solver.v2 + _axy(
         angle=helper.inv_moment2 * jnp.cross(helper.r2, p),
         xy=p * helper.inv_mass2,
     )
     return solver.replace(v1=v1, v2=v2)
 
 
+def _rv_a2b(a: jax.Array, ra: jax.Array, b: jax.Array, rb: jax.Array):
+    return Velocity.from_axy(b).rv(rb) - Velocity.from_axy(a).rv(ra)
+
+
 @jax.vmap
 def apply_velocity_normal(
     contact: Contact,
@@ -812,7 +826,7 @@ def apply_velocity_normal(
     Suppose that each shape has (N_contact, 1) or (N_contact, 2).
     """
     # Relative veclocity (from shape2 to shape1)
-    dv = _dv2from1(solver.v1, helper.r1, solver.v2, helper.r2)
+    dv = _rv_a2b(solver.v1, helper.r1, solver.v2, helper.r2)
     vt = jnp.dot(dv, helper.tangent)
     dpt = -helper.mass_tangent * vt
     # Clamp friction impulse
@@ -820,39 +834,34 @@ def apply_velocity_normal(
     pt = jnp.clip(solver.pt + dpt, a_min=-max_pt, a_max=max_pt)
     dpt_clamped = helper.tangent * (pt - solver.pt)
     # Velocity update by contact tangent
-    dvt1 = Velocity(
+    dvt1 = _axy(
         angle=-helper.inv_moment1 * jnp.cross(helper.r1, dpt_clamped),
         xy=-dpt_clamped * helper.inv_mass1,
     )
-    dvt2 = Velocity(
+    dvt2 = _axy(
         angle=helper.inv_moment2 * jnp.cross(helper.r2, dpt_clamped),
         xy=dpt_clamped * helper.inv_mass2,
     )
     # Compute Relative velocity again
-    dv = _dv2from1(solver.v1 + dvt1, helper.r1, solver.v2 + dvt2, helper.r2)
+    dv = _rv_a2b(solver.v1 + dvt1, helper.r1, solver.v2 + dvt2, helper.r2)
     vn = _vmap_dot(dv, contact.normal)
     dpn = helper.mass_normal * (-vn + helper.v_bias)
     # Accumulate and clamp impulse
     pn = jnp.clip(solver.pn + dpn, a_min=0.0)
     dpn_clamped = contact.normal * (pn - solver.pn)
     # Velocity update by contact normal
-    dvn1 = Velocity(
+    dvn1 = _axy(
         angle=-helper.inv_moment1 * jnp.cross(helper.r1, dpn_clamped),
         xy=-dpn_clamped * helper.inv_mass1,
     )
-    dvn2 = Velocity(
+    dvn2 = _axy(
         angle=helper.inv_moment2 * jnp.cross(helper.r2, dpn_clamped),
         xy=dpn_clamped * helper.inv_mass2,
     )
     # Filter dv
-    dv1, dv2 = jax.tree_map(
-        lambda x: jnp.where(solver.contact, x, 0.0),
-        (dvn1 + dvt1, dvn2 + dvt2),
-    )
-    # Summing up dv per each contact pair
     return VelocitySolver(
-        v1=dv1,
-        v2=dv2,
+        v1=jnp.where(solver.contact, dvn1 + dvt1, 0.0),
+        v2=jnp.where(solver.contact, dvn2 + dvt2, 0.0),
         pn=pn,
         pt=pt,
         contact=solver.contact,
@@ -870,28 +879,28 @@ def apply_bounce(
     Suppose that each shape has (N_contact, 1) or (N_contact, 2).
     """
     # Relative veclocity (from shape2 to shape1)
-    dv = _dv2from1(solver.v1, helper.r1, solver.v2, helper.r2)
+    dv = _rv_a2b(solver.v1, helper.r1, solver.v2, helper.r2)
     vn = jnp.dot(dv, contact.normal)
     pn = -helper.mass_normal * (vn + helper.bounce)
     dpn = contact.normal * pn
     # Velocity update by contact normal
-    dv1 = Velocity(
+    dv1 = _axy(
         angle=-helper.inv_moment1 * jnp.cross(helper.r1, dpn),
         xy=-dpn * helper.inv_mass1,
     )
-    dv2 = Velocity(
+    dv2 = _axy(
         angle=helper.inv_moment2 * jnp.cross(helper.r2, dpn),
         xy=dpn * helper.inv_mass2,
     )
     # Filter dv
     allow_bounce = jnp.logical_and(solver.contact, helper.allow_bounce)
-    return jax.tree_map(lambda x: jnp.where(allow_bounce, x, 0.0), (dv1, dv2))
+    return jnp.where(allow_bounce, dv1, 0.0), jnp.where(allow_bounce, dv2, 0.0)
 
 
 @chex.dataclass
 class PositionSolver:
-    p1: Position
-    p2: Position
+    p1: jax.Array
+    p2: jax.Array
     contact: jax.Array
     min_separation: jax.Array
 
@@ -911,9 +920,10 @@ def correct_position(
     p1 and p2 should have xy: (1, 2) angle (1, 1) shape
     """
     # (N_contact, 2)
-    r1 = solver.p1.rotate(helper.local_anchor1)
-    r2 = solver.p2.rotate(helper.local_anchor2)
-    ga2_ga1 = r2 - r1 + solver.p2.xy - solver.p1.xy
+    p1, p2 = Position.from_axy(solver.p1), Position.from_axy(solver.p2)
+    r1 = p1.rotate(helper.local_anchor1)
+    r2 = p2.rotate(helper.local_anchor2)
+    ga2_ga1 = r2 - r1 + p2.xy - p1.xy
     separation = jnp.dot(ga2_ga1, contact.normal) - contact.penetration
     c = jnp.clip(
         bias_factor * (separation + linear_slop),
@@ -925,21 +935,19 @@ def correct_position(
     k_normal = kn1 + kn2
     impulse = jnp.where(k_normal > 0.0, -c / k_normal, 0.0)
     pn = impulse * contact.normal
-    p1 = Position(
+    dp1 = _axy(
         angle=-helper.inv_moment1 * jnp.cross(r1, pn),
         xy=-pn * helper.inv_mass1,
     )
-    p2 = Position(
+    dp2 = _axy(
         angle=helper.inv_moment2 * jnp.cross(r2, pn),
         xy=pn * helper.inv_mass2,
     )
     min_sep = jnp.fmin(solver.min_separation, separation)
-    # Filter separation
-    p1, p2 = jax.tree_map(
-        lambda x: jnp.where(solver.contact, x, 0.0),
-        (p1, p2),
-    )
-    return solver.replace(p1=p1, p2=p2, min_separation=min_sep)
+    # Filter p1/p2
+    dp1 = jnp.where(solver.contact, dp1, 0.0)
+    dp2 = jnp.where(solver.contact, dp2, 0.0)
+    return solver.replace(p1=dp1, p2=dp2, min_separation=min_sep)
 
 
 def solve_constraints(
@@ -952,17 +960,8 @@ def solve_constraints(
     """Resolve collisions by Sequential Impulse method"""
     idx1, idx2 = space._ci_total.index1, space._ci_total.index2
 
-    def gather_and_pair(
-        a: _PositionLike,
-        b: _PositionLike,
-        orig: _PositionLike,
-    ) -> tuple[_PositionLike, _PositionLike, _PositionLike]:
-        xy = orig.xy.at[idx1].add(a.xy).at[idx2].add(b.xy)
-        angle = orig.angle.at[idx1].add(a.angle).at[idx2].add(b.angle)
-        cls = orig.__class__
-        a = cls(angle=angle[idx1], xy=xy[idx1])
-        b = cls(angle=angle[idx2], xy=xy[idx2])
-        return cls(angle=angle, xy=xy), a, b
+    def gather(a: jax.Array, b: jax.Array, orig: jax.Array) -> jax.Array:
+        return orig.at[idx1].add(a).at[idx2].add(b)
 
     p1, p2 = p.get_slice(idx1), p.get_slice(idx2)
     v1, v2 = v.get_slice(idx1), v.get_slice(idx2)
@@ -977,7 +976,8 @@ def gather_and_pair(
         v2,
     )
     # Warm up the velocity solver
-    solver = apply_initial_impulse(contact, helper, solver.replace(v1=v1, v2=v2))
+    solver = solver.replace(v1=v1.into_axy(), v2=v2.into_axy())
+    solver = apply_initial_impulse(contact, helper, solver)
 
     def vstep(
         _n_iter: int,
@@ -985,12 +985,17 @@ def vstep(
     ) -> tuple[Velocity, VelocitySolver]:
         v_i, solver_i = vs
         solver_i1 = apply_velocity_normal(contact, helper, solver_i)
-        v_i1, v1, v2 = gather_and_pair(solver_i1.v1, solver_i1.v2, v_i)
-        return v_i1, solver_i1.replace(v1=v1, v2=v2)
-
-    v, solver = jax.lax.fori_loop(0, space.n_velocity_iter, vstep, (v, solver))
+        v_i1 = gather(solver_i1.v1, solver_i1.v2, v_i)
+        return v_i1, solver_i1.replace(v1=v_i1[idx1], v2=v_i1[idx2])
+
+    v, solver = jax.lax.fori_loop(
+        0,
+        space.n_velocity_iter,
+        vstep,
+        (v.into_axy(), solver),
+    )
     bv1, bv2 = apply_bounce(contact, helper, solver)
-    v, _, _ = gather_and_pair(bv1, bv2, v)
+    v = gather(bv1, bv2, v)
 
     def pstep(
         _n_iter: int,
@@ -1005,17 +1010,22 @@ def pstep(
             helper,
             solver_i,
         )
-        p_i1, p1, p2 = gather_and_pair(solver_i1.p1, solver_i1.p2, p_i)
-        return p_i1, solver_i1.replace(p1=p1, p2=p2)
+        p_i1 = gather(solver_i1.p1, solver_i1.p2, p_i)
+        return p_i1, solver_i1.replace(p1=p_i1[idx1], p2=p_i1[idx2])
 
     pos_solver = PositionSolver(
-        p1=p1,
-        p2=p2,
+        p1=p1.into_axy(),
+        p2=p2.into_axy(),
         contact=solver.contact,
         min_separation=jnp.zeros_like(p1.angle),
     )
-    p, pos_solver = jax.lax.fori_loop(0, space.n_position_iter, pstep, (p, pos_solver))
-    return v, p, solver
+    p, pos_solver = jax.lax.fori_loop(
+        0,
+        space.n_position_iter,
+        pstep,
+        (p.into_axy(), pos_solver),
+    )
+    return Velocity.from_axy(v), Position.from_axy(p), solver
 
 
 def step(

From dbaec8b25eeb050b7bf7d40cc3a006d17774867a Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 30 Oct 2023 18:00:16 +0900
Subject: [PATCH 050/337] Observation

---
 smoke-tests/circle_loop.py                | 31 ++++++++++-------
 src/emevo/__init__.py                     |  7 ----
 src/emevo/environments/circle_foraging.py | 41 +++++++++++++++++++++--
 src/emevo/environments/phyjax2d.py        |  5 +--
 src/emevo/environments/phyjax2d_utils.py  | 26 --------------
 tests/test_observe.py                     | 10 ++++++
 6 files changed, 70 insertions(+), 50 deletions(-)
 create mode 100644 tests/test_observe.py

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index bb67d140..d8c5c328 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -25,28 +25,32 @@ def main(
     seed: int = 1,
     n_agents: int = 10,
     n_foods: int = 10,
-    debug: bool = False,
     forward_sensor: bool = False,
     use_test_env: bool = False,
     obstacles: bool = False,
     render: bool = False,
     replace: bool = False,
+    fixed_agent_loc: bool = False,
     env_shape: str = "square",
     food_loc_fn: str = "gaussian",
 ) -> None:
-    if debug:
-        import loguru
-
-        loguru.logger.enable("emevo")
-
-    if forward_sensor:
-        env_kwargs: dict[str, Any] = {
-            "sensor_range": (-30, 30),
-            "sensor_length": 100,
-            "foodloc_interval": 20,
+    if fixed_agent_loc:
+        additional_kwargs = {
+            "agent_loc_fn": (
+                "periodic",
+                [
+                    [40.0, 60.0],
+                    [60.0, 90.0],
+                    [80.0, 60.0],
+                    [100.0, 90.0],
+                    [120.0, 60.0],
+                ],
+            ),
+            "max_place_attempts": 40,
         }
+        n_agents = min(n_agents, 4)
     else:
-        env_kwargs = {"foodloc_interval": 20}
+        additional_kwargs = {}
 
     env = make(
         "CircleForaging-v0",
@@ -55,7 +59,8 @@ def main(
         n_initial_agents=n_agents,
         food_num_fn=("constant", n_foods),
         food_loc_fn=food_loc_fn,
-        **env_kwargs,
+        foodloc_interval=20,
+        **additional_kwargs,
     )
     key = jax.random.PRNGKey(seed)
     keys = jax.random.split(key, steps + 1)
diff --git a/src/emevo/__init__.py b/src/emevo/__init__.py
index 9767be61..5b563918 100644
--- a/src/emevo/__init__.py
+++ b/src/emevo/__init__.py
@@ -10,11 +10,4 @@
 from emevo.vec2d import Vec2d
 
 
-def __disable_loguru() -> None:
-    from loguru import logger
-
-    logger.disable("emevo")
-
-
-__disable_loguru()
 __version__ = "0.1.0"
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 3711427d..04c5017b 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -13,7 +13,15 @@
 from emevo.env import Env, Profile, Visualizer, init_profile
 from emevo.environments.phyjax2d import Position
 from emevo.environments.phyjax2d import Space as Physics
-from emevo.environments.phyjax2d import State, StateDict, Velocity, VelocitySolver
+from emevo.environments.phyjax2d import (
+    ShapeDict,
+    State,
+    StateDict,
+    Velocity,
+    VelocitySolver,
+    circle_raycast,
+    segment_raycast,
+)
 from emevo.environments.phyjax2d import nstep as physics_nstep
 from emevo.environments.phyjax2d_utils import (
     Color,
@@ -86,7 +94,7 @@ def stated(self) -> StateDict:
         return self.physics
 
     def is_extinct(self) -> bool:
-        return jnp.logical_not(jnp.any(self.profile.is_active()))
+        return jnp.logical_not(jnp.any(self.profile.is_active())).item()
 
 
 def _get_num_or_loc_fn(
@@ -163,6 +171,35 @@ def _make_physics(
     return builder.build(), seg_state
 
 
+def _observe_closest(
+    offset: float,
+    shaped: ShapeDict,
+    p1: jax.Array,
+    p2: jax.Array,
+    stated: StateDict,
+) -> None:
+    assert shaped.circle is not None and stated.circle is not None
+    assert shaped.static_circle is not None and stated.static_circle is not None
+    assert shaped.segment is not None and stated.segment is not None
+
+    frac = 1.0 + offset
+    rc = circle_raycast(0.0, frac, p2, p1, shaped.circle, stated.circle)
+    to_c = jnp.clip(jnp.where(rc.hit, rc.fraction, 0.0), a_min=offset)
+    rc = circle_raycast(
+        0.0,
+        frac,
+        p2,
+        p1,
+        shaped.static_circle,
+        stated.static_circle,
+    )
+    to_sc = jnp.clip(jnp.where(rc.hit, rc.fraction, 0.0), a_min=offset)
+    rc = segment_raycast(frac, p2, p1, shaped.segment, stated.segment)
+    to_seg = jnp.clip(jnp.where(rc.hit, rc.fraction, 0.0), a_min=offset)
+    obs = jnp.stack((to_c, to_sc, to_seg))
+    return jnp.where(obs == jnp.max(obs, axis=-1, keepdims=True), obs, 0.0)
+
+
 class CircleForaging(Env):
     def __init__(
         self,
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index c5a14c2d..f96730cf 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -687,8 +687,9 @@ def __post_init__(self) -> None:
     def check_contacts(self, stated: StateDict) -> Contact:
         contacts = []
         for (n1, n2), fn in _CONTACT_FUNCTIONS.items():
-            if stated[n1] is not None and stated[n2] is not None:
-                contacts.append(fn(self._ci[n1, n2], stated))
+            ci = self._ci.get((n1, n2), None)
+            if ci is not None:
+                contacts.append(fn(ci, stated))
         return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *contacts)
 
     def n_possible_contacts(self) -> int:
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 22479e9f..322b17d5 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -13,12 +13,9 @@
     Shape,
     ShapeDict,
     Space,
-    State,
     StateDict,
     _length_to_points,
     _vmap_dot,
-    circle_raycast,
-    segment_raycast,
 )
 from emevo.vec2d import Vec2d, Vec2dLike
 
@@ -331,26 +328,3 @@ def circle_overwrap(
         overwrap2seg = jnp.array(False)
 
     return jnp.logical_or(overwrap2cir, overwrap2seg)
-
-
-def raycast_closest(
-    fraction: float,
-    p1: jax.Array,
-    p2: jax.Array,
-    shaped: ShapeDict,
-    stated: StateDict,
-):
-    if shaped.circle is not None:
-        rc = circle_raycast(0.0, fraction, p1, p2, shaped.circle, stated.circle)
-        jnp.where(rc.hit, rc.fraction, 0.0)
-    if shaped.static_circle is not None:
-        rc = circle_raycast(
-            0.0,
-            fraction,
-            p1,
-            p2,
-            shaped.static_circle,
-            stated.static_circle,
-        )
-    if shaped.segment is not None:
-        rc = segment_raycast(fraction, p1, p2, shaped.segment, stated.segment)
diff --git a/tests/test_observe.py b/tests/test_observe.py
new file mode 100644
index 00000000..886b5d99
--- /dev/null
+++ b/tests/test_observe.py
@@ -0,0 +1,10 @@
+import chex
+import jax
+import jax.numpy as jnp
+import pytest
+
+from emevo.environments.circle_foraging import _make_physics
+from emevo.environments.phyjax2d import Space, StateDict
+from emevo.environments.placement import place_agent, place_food
+from emevo.environments.utils.food_repr import ReprLoc
+from emevo.environments.utils.locating import CircleCoordinate, InitLoc

From 3f235fa9a80ab27336e344d1722f0dee330b8896 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 31 Oct 2023 01:39:29 +0900
Subject: [PATCH 051/337] Unify ReprLoc/InitLoc

---
 src/emevo/environments/circle_foraging.py     | 101 ++++++++++--------
 .../environments/{utils => }/locating.py      |  96 +++++++++++------
 src/emevo/environments/placement.py           |  65 +++--------
 .../{utils/food_repr.py => reproduction.py}   |  82 +-------------
 src/emevo/environments/utils/__init__.py      |   0
 tests/test_observe.py                         |   2 -
 tests/test_placement.py                       |  13 ++-
 7 files changed, 142 insertions(+), 217 deletions(-)
 rename src/emevo/environments/{utils => }/locating.py (55%)
 rename src/emevo/environments/{utils/food_repr.py => reproduction.py} (53%)
 delete mode 100644 src/emevo/environments/utils/__init__.py

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 04c5017b..1a2b4962 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -11,39 +11,32 @@
 from jax.typing import ArrayLike
 
 from emevo.env import Env, Profile, Visualizer, init_profile
-from emevo.environments.phyjax2d import Position
+from emevo.environments.locating import (
+    CircleCoordinate,
+    Locating,
+    LocatingFn,
+    LocatingState,
+    SquareCoordinate,
+)
+from emevo.environments.phyjax2d import Position, ShapeDict
 from emevo.environments.phyjax2d import Space as Physics
 from emevo.environments.phyjax2d import (
-    ShapeDict,
     State,
     StateDict,
     Velocity,
     VelocitySolver,
     circle_raycast,
-    segment_raycast,
 )
 from emevo.environments.phyjax2d import nstep as physics_nstep
+from emevo.environments.phyjax2d import segment_raycast
 from emevo.environments.phyjax2d_utils import (
     Color,
     SpaceBuilder,
     make_approx_circle,
     make_square,
 )
-from emevo.environments.placement import place_agent, place_food
-from emevo.environments.utils.food_repr import (
-    FoodNumState,
-    ReprLoc,
-    ReprLocFn,
-    ReprLocState,
-    ReprNum,
-    ReprNumFn,
-)
-from emevo.environments.utils.locating import (
-    CircleCoordinate,
-    InitLoc,
-    InitLocFn,
-    SquareCoordinate,
-)
+from emevo.environments.placement import place
+from emevo.environments.reproduction import FoodNumState, ReprNum, ReprNumFn
 from emevo.spaces import BoxSpace, NamedTupleSpace
 from emevo.types import Index
 from emevo.vec2d import Vec2d
@@ -83,7 +76,8 @@ class CFState:
     physics: StateDict
     solver: VelocitySolver
     food_num: FoodNumState
-    repr_loc: ReprLocState
+    agent_loc: LocatingState
+    food_loc: LocatingState
     key: chex.PRNGKey
     step: jax.Array
     profile: Profile
@@ -98,10 +92,12 @@ def is_extinct(self) -> bool:
 
 
 def _get_num_or_loc_fn(
-    arg: str | tuple | list,
+    arg: str | tuple | list | Callable[..., Any],
     enum_type: Callable[..., Callable[..., Any]],
     default_args: dict[str, tuple[Any, ...]],
 ) -> Any:
+    if callable(arg):
+        return arg
     if isinstance(arg, str):
         return enum_type(arg)(*default_args[arg])
     elif isinstance(arg, tuple) or isinstance(arg, list):
@@ -207,8 +203,8 @@ def __init__(
         n_max_agents: int = 100,
         n_max_foods: int = 40,
         food_num_fn: ReprNumFn | str | tuple[str, ...] = "constant",
-        food_loc_fn: ReprLocFn | str | tuple[str, ...] = "gaussian",
-        agent_loc_fn: InitLocFn | str | tuple[str, ...] = "uniform",
+        food_loc_fn: LocatingFn | str | tuple[str, ...] = "gaussian",
+        agent_loc_fn: LocatingFn | str | tuple[str, ...] = "uniform",
         xlim: tuple[float, float] = (0.0, 200.0),
         ylim: tuple[float, float] = (0.0, 200.0),
         env_radius: float = 120.0,
@@ -249,7 +245,9 @@ def __init__(
         self._food_num_fn, self._initial_foodnum_state = self._make_food_num_fn(
             food_num_fn
         )
-        self._agent_loc_fn = self._make_agent_loc_fn(agent_loc_fn)
+        self._agent_loc_fn, self._initial_agentloc_state = self._make_agent_loc_fn(
+            agent_loc_fn
+        )
         # Initial numbers
         assert n_max_agents > n_initial_agents
         assert n_max_foods > self._food_num_fn.initial
@@ -295,21 +293,21 @@ def __init__(
         self._act_p2 = jnp.tile(jnp.array(act_p2), (N, 1))
         self._place_agent = jax.jit(
             functools.partial(
-                place_agent,
+                place,
                 n_trial=self._max_place_attempts,
-                agent_radius=self._agent_radius,
+                radius=self._agent_radius,
                 coordinate=self._coordinate,
-                initloc_fn=self._agent_loc_fn,
+                loc_fn=self._agent_loc_fn,
                 shaped=self._physics.shaped,
             )
         )
         self._place_food = jax.jit(
             functools.partial(
-                place_food,
+                place,
                 n_trial=self._max_place_attempts,
-                food_radius=self._food_radius,
+                radius=self._food_radius,
                 coordinate=self._coordinate,
-                reprloc_fn=self._food_loc_fn,
+                loc_fn=self._food_loc_fn,
                 shaped=self._physics.shaped,
             )
         )
@@ -327,11 +325,11 @@ def _make_food_num_fn(
 
     def _make_food_loc_fn(
         self,
-        food_loc_fn: str | tuple | ReprLocFn,
-    ) -> tuple[ReprLocFn, ReprLocState]:
+        food_loc_fn: str | tuple | LocatingFn,
+    ) -> tuple[LocatingFn, LocatingState]:
         return _get_num_or_loc_fn(
             food_loc_fn,
-            ReprLoc,  # type: ignore
+            Locating,  # type: ignore
             {
                 "gaussian": (
                     (self._xlim[1] * 0.75, self._ylim[1] * 0.75),
@@ -362,10 +360,13 @@ def _make_food_loc_fn(
             },
         )
 
-    def _make_agent_loc_fn(self, init_loc_fn: str | tuple | InitLocFn) -> InitLocFn:
+    def _make_agent_loc_fn(
+        self,
+        init_loc_fn: str | tuple | LocatingFn,
+    ) -> tuple[LocatingFn, LocatingState]:
         return _get_num_or_loc_fn(
             init_loc_fn,
-            InitLoc,  # type: ignore
+            Locating,  # type: ignore
             {
                 "gaussian": (
                     (self._xlim[1] * 0.25, self._ylim[1] * 0.25),
@@ -378,10 +379,10 @@ def _make_agent_loc_fn(self, init_loc_fn: str | tuple | InitLocFn) -> InitLocFn:
     def set_food_num_fn(self, food_num_fn: str | tuple | ReprNumFn) -> None:
         self._food_num_fn = self._make_food_num_fn(food_num_fn)
 
-    def set_food_loc_fn(self, food_loc_fn: str | tuple | ReprLocFn) -> None:
+    def set_food_loc_fn(self, food_loc_fn: str | tuple | LocatingFn) -> None:
         self._food_loc_fn = self._make_food_loc_fn(food_loc_fn)
 
-    def set_agent_loc_fn(self, agent_loc_fn: str | tuple | InitLocFn) -> None:
+    def set_agent_loc_fn(self, agent_loc_fn: str | tuple | LocatingFn) -> None:
         self._agent_loc_fn = self._make_agent_loc_fn(agent_loc_fn)
 
     def step(self, state: CFState, action: ArrayLike) -> CFState:
@@ -459,14 +460,13 @@ def success() -> tuple[CFState, bool]:
 
     def reset(self, key: chex.PRNGKey) -> CFState:
         state_key, init_key = jax.random.split(key)
-        stated = self._initialize_physics_state(init_key)
-        repr_loc = self._initial_foodloc_state
-        food_num = self._initial_foodnum_state
-        return CFState(
-            physics=stated,
+        physics, agent_loc, food_loc = self._initialize_physics_state(init_key)
+        return CFState(  # type: ignore
+            physics=physics,
             solver=self._physics.init_solver(),
-            repr_loc=repr_loc,
-            food_num=food_num,
+            agent_loc=agent_loc,
+            food_loc=food_loc,
+            food_num=self._initial_foodnum_state,
             # Protocols
             key=state_key,
             step=jnp.array(0, dtype=jnp.int32),
@@ -474,7 +474,10 @@ def reset(self, key: chex.PRNGKey) -> CFState:
             n_born_agents=jnp.array(self._n_initial_agents, dtype=jnp.int32),
         )
 
-    def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
+    def _initialize_physics_state(
+        self,
+        key: chex.PRNGKey,
+    ) -> tuple[StateDict, LocatingState, LocatingState]:
         stated = self._physics.shaped.zeros_state()
         assert stated.circle is not None
 
@@ -504,13 +507,15 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
         )
         keys = jax.random.split(key, self._n_initial_foods + self._n_initial_agents)
         agent_failed = 0
+        agentloc_state = self._initial_foodloc_state
         for i, key in enumerate(keys[: self._n_initial_agents]):
-            xy = self._place_agent(key=key, stated=stated)
+            xy = self._place_agent(loc_state=agentloc_state, key=key, stated=stated)
             if jnp.all(xy < jnp.inf):
                 stated = stated.nested_replace(
                     "circle.p.xy",
                     stated.circle.p.xy.at[i].set(xy),
                 )
+                agentloc_state = agentloc_state.increment()
             else:
                 agent_failed += 1
 
@@ -520,19 +525,21 @@ def _initialize_physics_state(self, key: chex.PRNGKey) -> StateDict:
         food_failed = 0
         foodloc_state = self._initial_foodloc_state
         for i, key in enumerate(keys[self._n_initial_foods :]):
-            xy = self._place_food(reprloc_state=foodloc_state, key=key, stated=stated)
+            xy = self._place_food(loc_state=foodloc_state, key=key, stated=stated)
             if jnp.all(xy < jnp.inf):
                 stated = stated.nested_replace(
                     "static_circle.p.xy",
                     stated.static_circle.p.xy.at[i].set(xy),
                 )
+                foodloc_state = foodloc_state.increment()
             else:
                 food_failed += 1
 
         if food_failed > 0:
             warnings.warn(f"Failed to place {food_failed} foods!", stacklevel=1)
 
-        return stated.replace(segment=self._segment_state)
+        stated = stated.replace(segment=self._segment_state)
+        return stated, agentloc_state, foodloc_state
 
     def visualizer(
         self,
diff --git a/src/emevo/environments/utils/locating.py b/src/emevo/environments/locating.py
similarity index 55%
rename from src/emevo/environments/utils/locating.py
rename to src/emevo/environments/locating.py
index b7abb222..70872750 100644
--- a/src/emevo/environments/utils/locating.py
+++ b/src/emevo/environments/locating.py
@@ -10,6 +10,8 @@
 import jax.numpy as jnp
 from jax.typing import ArrayLike
 
+Self = Any
+
 
 class Coordinate(Protocol):
     def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]:
@@ -74,48 +76,60 @@ def uniform(self, key: chex.PRNGKey) -> jax.Array:
         return jax.random.uniform(key, shape=(2,), minval=low, maxval=high)
 
 
-InitLocFn = Callable[[chex.PRNGKey], jax.Array]
+@chex.dataclass
+class LocatingState:
+    n_produced: jax.Array
+
+    def increment(self) -> Self:
+        return self.replace(n_produced=self.n_produced + 1)
+
 
+LocatingFn = Callable[[chex.PRNGKey, LocatingState], jax.Array]
 
-class InitLoc(str, enum.Enum):
+
+class Locating(str, enum.Enum):
     """Methods to determine the location of new foods or agents"""
 
-    CHOICE = "choice"
     GAUSSIAN = "gaussian"
     GAUSSIAN_MIXTURE = "gaussian-mixture"
+    PERIODIC = "periodic"
+    SWITCHING = "switching"
     UNIFORM = "uniform"
 
-    def __call__(self, *args: Any, **kwargs: Any) -> InitLocFn:
-        if self is InitLoc.CHOICE:
-            return init_loc_choice(*args, **kwargs)
-        elif self is InitLoc.GAUSSIAN:
-            return init_loc_gaussian(*args, **kwargs)
-        elif self is InitLoc.GAUSSIAN_MIXTURE:
-            return init_loc_gaussian_mixture(*args, **kwargs)
-        elif self is InitLoc.UNIFORM:
-            return init_loc_uniform(*args, **kwargs)
+    def __call__(self, *args: Any, **kwargs: Any) -> tuple[LocatingFn, LocatingState]:
+        state = LocatingState(n_produced=jnp.array(0, dtype=jnp.int32))
+        if self is Locating.GAUSSIAN:
+            return loc_gaussian(*args, **kwargs), state
+        elif self is Locating.GAUSSIAN_MIXTURE:
+            return loc_gaussian_mixture(*args, **kwargs), state
+        elif self is Locating.PERIODIC:
+            return LocPeriodic(*args, **kwargs), state
+        elif self is Locating.UNIFORM:
+            return loc_uniform(*args, **kwargs), state
+        elif self is Locating.SWITCHING:
+            return LocSwitching(*args, **kwargs), state
         else:
             raise AssertionError("Unreachable")
 
 
-def init_loc_gaussian(mean: ArrayLike, stddev: ArrayLike) -> InitLocFn:
+def loc_gaussian(mean: ArrayLike, stddev: ArrayLike) -> LocatingFn:
     mean_a = jnp.array(mean)
     std_a = jnp.array(stddev)
     shape = mean_a.shape
-    return lambda key: jax.random.normal(key, shape=shape) * std_a + mean_a
+    return lambda key, _state: jax.random.normal(key, shape=shape) * std_a + mean_a
 
 
-def init_loc_gaussian_mixture(
+def loc_gaussian_mixture(
     probs: ArrayLike,
     mean_arr: ArrayLike,
     stddev_arr: ArrayLike,
-) -> InitLocFn:
+) -> LocatingFn:
     mean_a = jnp.array(mean_arr)
     stddev_a = jnp.array(stddev_arr)
     probs_a = jnp.array(probs)
     n = probs_a.shape[0]
 
-    def sample(key: chex.PRNGKey) -> jax.Array:
+    def sample(key: chex.PRNGKey, _state: LocatingState) -> jax.Array:
         k1, k2 = jax.random.split(key)
         i = jax.random.choice(k1, n, p=probs_a)
         mi, si = mean_a[i], stddev_a[i]
@@ -124,16 +138,38 @@ def sample(key: chex.PRNGKey) -> jax.Array:
     return sample
 
 
-def init_loc_choice(locations: Iterable[jax.Array]) -> InitLocFn:
-    loc_a = jnp.array(list(locations))
-    n = loc_a.shape[0]
-
-    def sample(key: chex.PRNGKey) -> jax.Array:
-        i = jax.random.choice(key, n)
-        return loc_a[i]
-
-    return sample
-
-
-def init_loc_uniform(coordinate: Coordinate) -> InitLocFn:
-    return lambda key: coordinate.uniform(key)
+def loc_uniform(coordinate: Coordinate) -> LocatingFn:
+    return lambda key, _state: coordinate.uniform(key)
+
+
+class LocPeriodic:
+    def __init__(self, *locations: Iterable[ArrayLike]) -> None:
+        self._locations = jnp.array(list(locations))
+        self._n = self._locations.shape[0]
+
+    def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
+        count = state.n_produced + 1
+        return self._locations[count % self._n]
+
+
+class LocSwitching:
+    def __init__(
+        self,
+        interval: int,
+        *loc_fns: Iterable[tuple[str, ...] | LocatingFn],
+    ) -> None:
+        locfn_list = []
+        for fn_or_base in loc_fns:
+            if callable(fn_or_base):
+                locfn_list.append(fn_or_base)
+            else:
+                name, *args = fn_or_base
+                locfn_list.append(Locating(name)(*args))
+        self._locfn_list = locfn_list
+        self._interval = interval
+        self._n = len(locfn_list)
+
+    def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
+        count = state.n_produced + 1
+        index = (count // self._interval) % self._n
+        return jax.lax.switch(index, self._locfn_list, key)
diff --git a/src/emevo/environments/placement.py b/src/emevo/environments/placement.py
index 855ba27d..84313d69 100644
--- a/src/emevo/environments/placement.py
+++ b/src/emevo/environments/placement.py
@@ -4,23 +4,30 @@
 import jax
 import jax.numpy as jnp
 
+from emevo.environments.locating import Coordinate, LocatingFn, LocatingState
 from emevo.environments.phyjax2d import ShapeDict, StateDict
 from emevo.environments.phyjax2d_utils import circle_overwrap
-from emevo.environments.utils.food_repr import ReprLocFn, ReprLocState
-from emevo.environments.utils.locating import Coordinate, InitLocFn
 
-_vmap_co = jax.vmap(circle_overwrap, in_axes=(None, None, 0, 0))
+_vmap_co = jax.vmap(circle_overwrap, in_axes=(None, None, 0, None))
 
 
-def _place_common(
+def place(
+    n_trial: int,
+    radius: float,
     coordinate: Coordinate,
+    loc_fn: LocatingFn,
+    loc_state: LocatingState,
+    key: chex.PRNGKey,
     shaped: ShapeDict,
     stated: StateDict,
-    locations: jax.Array,
-    radius: jax.Array,
 ) -> jax.Array:
+    """Returns `[inf, inf]` if it fails"""
+    keys = jax.random.split(key, n_trial)
+    vmap_loc_fn = jax.vmap(loc_fn, in_axes=(0, None))
+    locations = vmap_loc_fn(keys, loc_state)
+    contains_fn = jax.vmap(coordinate.contains_circle, in_axes=(0, None))
     ok = jnp.logical_and(
-        jax.vmap(coordinate.contains_circle)(locations, radius),
+        contains_fn(locations, radius),
         jnp.logical_not(_vmap_co(shaped, stated, locations, radius)),
     )
     (ok_idx,) = jnp.nonzero(ok, size=1, fill_value=-1)
@@ -30,47 +37,3 @@ def _place_common(
         lambda: jnp.ones(2) * jnp.inf,
         lambda: locations[ok_idx],
     )
-
-
-def place_food(
-    n_trial: int,
-    food_radius: float,
-    coordinate: Coordinate,
-    reprloc_fn: ReprLocFn,
-    reprloc_state: ReprLocState,
-    key: chex.PRNGKey,
-    shaped: ShapeDict,
-    stated: StateDict,
-) -> jax.Array:
-    """Returns `[inf, inf]` if it fails"""
-    keys = jax.random.split(key, n_trial)
-    loc_fn = jax.vmap(reprloc_fn, in_axes=(0, None))
-    locations = loc_fn(keys, reprloc_state)
-    return _place_common(
-        coordinate,
-        shaped,
-        stated,
-        locations,
-        jnp.ones(n_trial) * food_radius,
-    )
-
-
-def place_agent(
-    n_trial: int,
-    agent_radius: float,
-    coordinate: Coordinate,
-    initloc_fn: InitLocFn,
-    key: chex.PRNGKey,
-    shaped: ShapeDict,
-    stated: StateDict,
-) -> jax.Array:
-    """Returns `[inf, inf]` if it fails"""
-    keys = jax.random.split(key, n_trial)
-    locations = jax.vmap(initloc_fn)(keys)
-    return _place_common(
-        coordinate,
-        shaped,
-        stated,
-        locations,
-        jnp.ones(n_trial) * agent_radius,
-    )
diff --git a/src/emevo/environments/utils/food_repr.py b/src/emevo/environments/reproduction.py
similarity index 53%
rename from src/emevo/environments/utils/food_repr.py
rename to src/emevo/environments/reproduction.py
index b365d60f..324337ce 100644
--- a/src/emevo/environments/utils/food_repr.py
+++ b/src/emevo/environments/reproduction.py
@@ -1,26 +1,15 @@
-"""
-Utility functions to write food reproduction code in foraging environments.
+""" Utility functions to write food reproduction code in foraging environments.
 """
 from __future__ import annotations
 
 import dataclasses
 import enum
-from collections.abc import Iterable
-from typing import Any, Callable, Protocol
+from typing import Any, Protocol
 
 import chex
 import jax
 import jax.numpy as jnp
 
-from emevo.environments.utils.locating import (
-    InitLoc,
-    InitLocFn,
-    init_loc_gaussian,
-    init_loc_gaussian_mixture,
-    init_loc_choice,
-    init_loc_uniform,
-)
-
 Self = Any
 
 
@@ -108,70 +97,3 @@ def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn, FoodNumState]:
         else:
             raise AssertionError("Unreachable")
         return fn, state
-
-
-@chex.dataclass
-class ReprLocState:
-    n_produced: jax.Array
-
-    def step(self) -> Self:
-        return self.replace(n_produced=self.n_produced + 1)
-
-
-ReprLocFn = Callable[[chex.PRNGKey, ReprLocState], jax.Array]
-
-
-def _wrap_initloc(fn: InitLocFn) -> ReprLocFn:
-    return lambda key, _: fn(key)
-
-
-class ReprLocSwitching:
-    def __init__(
-        self,
-        interval: int,
-        *initloc_fns: Iterable[tuple[str, ...] | InitLocFn],
-    ) -> None:
-        locfn_list = []
-        for fn_or_base in initloc_fns:
-            if callable(fn_or_base):
-                locfn_list.append(fn_or_base)
-            else:
-                name, *args = fn_or_base
-                locfn_list.append(InitLoc(name)(*args))
-        self._locfn_list = locfn_list
-        self._interval = interval
-        self._n = len(locfn_list)
-
-    def __call__(
-        self,
-        key: chex.PRNGKey,
-        state: ReprLocState,
-    ) -> jax.Array:
-        count = state.n_produced + 1
-        index = (count // self._interval) % self._n
-        return jax.lax.switch(index, self._locfn_list, key)
-
-
-class ReprLoc(str, enum.Enum):
-    """Methods to determine the location of new foods or agents"""
-
-    CHOICE = "choice"
-    GAUSSIAN = "gaussian"
-    GAUSSIAN_MIXTURE = "gaussian-mixture"
-    SWITCHING = "switching"
-    UNIFORM = "uniform"
-
-    def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprLocFn, Any]:
-        state = ReprLocState(n_produced=jnp.array(0, dtype=jnp.int32))
-        if self is ReprLoc.GAUSSIAN:
-            return _wrap_initloc(init_loc_gaussian(*args, **kwargs)), state
-        elif self is ReprLoc.GAUSSIAN_MIXTURE:
-            return _wrap_initloc(init_loc_gaussian_mixture(*args, **kwargs)), state
-        elif self is ReprLoc.CHOICE:
-            return _wrap_initloc(init_loc_choice(*args, **kwargs)), state
-        elif self is ReprLoc.SWITCHING:
-            return ReprLocSwitching(*args, **kwargs), state
-        elif self is ReprLoc.UNIFORM:
-            return _wrap_initloc(init_loc_uniform(*args, **kwargs)), state
-        else:
-            raise AssertionError("Unreachable")
diff --git a/src/emevo/environments/utils/__init__.py b/src/emevo/environments/utils/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/tests/test_observe.py b/tests/test_observe.py
index 886b5d99..d6337ded 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -6,5 +6,3 @@
 from emevo.environments.circle_foraging import _make_physics
 from emevo.environments.phyjax2d import Space, StateDict
 from emevo.environments.placement import place_agent, place_food
-from emevo.environments.utils.food_repr import ReprLoc
-from emevo.environments.utils.locating import CircleCoordinate, InitLoc
diff --git a/tests/test_placement.py b/tests/test_placement.py
index c080cf52..d69c2a06 100644
--- a/tests/test_placement.py
+++ b/tests/test_placement.py
@@ -6,8 +6,7 @@
 from emevo.environments.circle_foraging import _make_physics
 from emevo.environments.phyjax2d import Space, StateDict
 from emevo.environments.placement import place_agent, place_food
-from emevo.environments.utils.food_repr import ReprLoc
-from emevo.environments.utils.locating import CircleCoordinate, InitLoc
+from emevo.environments.locating import CircleCoordinate, Locating
 
 N_MAX_AGENTS = 20
 N_MAX_FOODS = 10
@@ -38,14 +37,14 @@ def test_place_agents(key) -> None:
     n = N_MAX_AGENTS // 2
     keys = jax.random.split(key, n)
     space, stated, coordinate = get_space_and_more()
-    initloc_fn = InitLoc.UNIFORM(CircleCoordinate((100.0, 100.0), 95.0))
+    initloc_fn, _ = Locating.UNIFORM(CircleCoordinate((100.0, 100.0), 95.0))
     assert stated.circle is not None
     for i, key in enumerate(keys):
         xy = place_agent(
             n_trial=10,
             agent_radius=AGENT_RADIUS,
             coordinate=coordinate,
-            initloc_fn=initloc_fn,
+            loc_fn=initloc_fn,
             key=key,
             shaped=space.shaped,
             stated=stated,
@@ -70,15 +69,15 @@ def test_place_foods(key) -> None:
     n = N_MAX_FOODS // 2
     keys = jax.random.split(key, n)
     space, stated, coordinate = get_space_and_more()
-    reprloc_fn, reprloc_state = ReprLoc.UNIFORM(CircleCoordinate((100.0, 100.0), 95.0))
+    reprloc_fn, reprloc_state = Locating.UNIFORM(CircleCoordinate((100.0, 100.0), 95.0))
     assert stated.static_circle is not None
     for i, key in enumerate(keys):
         xy = place_food(
             n_trial=10,
             food_radius=FOOD_RADIUS,
             coordinate=coordinate,
-            reprloc_fn=reprloc_fn,
-            reprloc_state=reprloc_state,
+            loc_fn=reprloc_fn,
+            loc_state=reprloc_state,
             key=key,
             shaped=space.shaped,
             stated=stated,

From abf6ec0949af5cac7159d8afe49d54800a572530 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 31 Oct 2023 13:47:59 +0900
Subject: [PATCH 052/337] Fix tests

---
 smoke-tests/circle_loop.py                | 15 +++---
 src/emevo/environments/circle_foraging.py |  2 +-
 src/emevo/environments/locating.py        | 16 +++---
 src/emevo/environments/phyjax2d.py        |  2 +-
 tests/test_env_utils.py                   | 65 ++++++++++-------------
 tests/test_observe.py                     |  1 -
 tests/test_placement.py                   | 21 ++++----
 7 files changed, 53 insertions(+), 69 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index d8c5c328..e5905443 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -38,17 +38,14 @@ def main(
         additional_kwargs = {
             "agent_loc_fn": (
                 "periodic",
-                [
-                    [40.0, 60.0],
-                    [60.0, 90.0],
-                    [80.0, 60.0],
-                    [100.0, 90.0],
-                    [120.0, 60.0],
-                ],
+                [40.0, 60.0],
+                [60.0, 90.0],
+                [80.0, 60.0],
+                [100.0, 90.0],
+                [120.0, 60.0],
             ),
-            "max_place_attempts": 40,
         }
-        n_agents = min(n_agents, 4)
+        n_agents = min(n_agents, 5)
     else:
         additional_kwargs = {}
 
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 1a2b4962..3702dd4a 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -412,7 +412,7 @@ def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool
             fill_value=-1,
         )
         index = index[0]
-        xy = self._place_agent(key=key, stated=state.physics)
+        xy = self._place_agent(key=activate_key, stated=state.physics)
         ok = jnp.logical_and(index >= 0, jnp.all(xy < jnp.inf))
 
         def success() -> tuple[CFState, bool]:
diff --git a/src/emevo/environments/locating.py b/src/emevo/environments/locating.py
index 70872750..af4d2ad8 100644
--- a/src/emevo/environments/locating.py
+++ b/src/emevo/environments/locating.py
@@ -143,20 +143,19 @@ def loc_uniform(coordinate: Coordinate) -> LocatingFn:
 
 
 class LocPeriodic:
-    def __init__(self, *locations: Iterable[ArrayLike]) -> None:
-        self._locations = jnp.array(list(locations))
+    def __init__(self, *locations: ArrayLike) -> None:
+        self._locations = jnp.array(locations)
         self._n = self._locations.shape[0]
 
-    def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
-        count = state.n_produced + 1
-        return self._locations[count % self._n]
+    def __call__(self, _key: chex.PRNGKey, state: LocatingState) -> jax.Array:
+        return self._locations[state.n_produced % self._n]
 
 
 class LocSwitching:
     def __init__(
         self,
         interval: int,
-        *loc_fns: Iterable[tuple[str, ...] | LocatingFn],
+        *loc_fns: tuple[str, ...] | LocatingFn,
     ) -> None:
         locfn_list = []
         for fn_or_base in loc_fns:
@@ -170,6 +169,5 @@ def __init__(
         self._n = len(locfn_list)
 
     def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
-        count = state.n_produced + 1
-        index = (count // self._interval) % self._n
-        return jax.lax.switch(index, self._locfn_list, key)
+        index = (state.n_produced // self._interval) % self._n
+        return jax.lax.switch(index, self._locfn_list, key, state)
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index f96730cf..d62a5720 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -267,7 +267,7 @@ def apply_force_global(self, point: jax.Array, force: jax.Array) -> Self:
     def apply_force_local(self, point: jax.Array, force: jax.Array) -> Self:
         chex.assert_equal_shape((self.p.xy, point))
         point = self.p.transform(point)
-        return self.apply_force_global(point, force)
+        return self.apply_force_global(point, self.p.rotate(force))
 
     def batch_size(self) -> int:
         return self.p.batch_size()
diff --git a/tests/test_env_utils.py b/tests/test_env_utils.py
index 52ae7975..fa4df813 100644
--- a/tests/test_env_utils.py
+++ b/tests/test_env_utils.py
@@ -3,10 +3,11 @@
 import jax.numpy as jnp
 import pytest
 
-from emevo.environments.utils.food_repr import ReprLoc, ReprNum
-from emevo.environments.utils.locating import (
+from emevo.environments.reproduction import  ReprNum
+from emevo.environments.locating import (
     CircleCoordinate,
-    InitLoc,
+    Locating,
+    LocatingFn,
     SquareCoordinate,
 )
 
@@ -36,63 +37,51 @@ def test_square_coordinate(key: chex.PRNGKey) -> None:
     assert jnp.all(jax.vmap(bigger_square.contains_circle)(arr, jnp.ones(10))), arr
 
 
-def test_initloc_gaussian(key: chex.PRNGKey) -> None:
-    initloc_g = InitLoc.GAUSSIAN((3.0, 3.0), (1.0, 1.0))
-    loc = jax.vmap(initloc_g)(jax.random.split(key, 10))
+def test_loc_gaussian(key: chex.PRNGKey) -> None:
+    loc_g, state = Locating.GAUSSIAN((3.0, 3.0), (1.0, 1.0))
+    loc = jax.vmap(loc_g, in_axes=(0, None))(jax.random.split(key, 10), state)
     chex.assert_shape(loc, (10, 2))
     x_mean = jnp.mean(loc[:, 0])
     y_mean = jnp.mean(loc[:, 1])
     assert (x_mean - 3) ** 2 < 1.0 and (y_mean - 3) ** 2 < 1.0
 
 
-def test_initloc_uniform(key: chex.PRNGKey) -> None:
-    initloc_u = InitLoc.UNIFORM(CircleCoordinate((3.0, 3.0), 3.0))
-    loc = jax.vmap(initloc_u)(jax.random.split(key, 10))
+def test_loc_uniform(key: chex.PRNGKey) -> None:
+    loc_u, state = Locating.UNIFORM(CircleCoordinate((3.0, 3.0), 3.0))
+    loc = jax.vmap(loc_u, in_axes=(0, None))(jax.random.split(key, 10), state)
     chex.assert_shape(loc, (10, 2))
     bigger_circle = CircleCoordinate((3.0, 3.0), 4.0)
     assert jnp.all(jax.vmap(bigger_circle.contains_circle)(loc, jnp.ones(10)))
 
 
-def test_initloc_gm(key: chex.PRNGKey) -> None:
-    initloc_gm = InitLoc.GAUSSIAN_MIXTURE(
+def test_loc_gm(key: chex.PRNGKey) -> None:
+    loc_gm, state = Locating.GAUSSIAN_MIXTURE(
         [0.3, 0.7],
         ((0.0, 0.0), (10.0, 10.0)),
         ((1.0, 1.0), (1.0, 1.0)),
     )
-    loc = jax.vmap(initloc_gm)(jax.random.split(key, 20))
+    loc = jax.vmap(loc_gm, in_axes=(0, None))(jax.random.split(key, 20), state)
     chex.assert_shape(loc, (20, 2))
     x_mean = jnp.mean(loc[:, 0])
     y_mean = jnp.mean(loc[:, 1])
     assert (x_mean - 7) ** 2 < 1.0 and (y_mean - 7) ** 2 < 1.0
 
 
-def test_initloc_choice(key: chex.PRNGKey) -> None:
-    initloc_c = InitLoc.CHOICE([(0.0, 0.0), (1.0, 1.0), (2.0, 2.0)])
-    loc = jax.vmap(initloc_c)(jax.random.split(key, 20))
-    chex.assert_shape(loc, (20, 2))
-    c1 = loc == jnp.array([[0.0, 0.0]])
-    c2 = loc == jnp.array([[1.0, 1.0]])
-    c3 = loc == jnp.array([[2.0, 2.0]])
-    assert jnp.all(jnp.logical_or(c1, jnp.logical_or(c2, c3)))
-
-
-def test_reprloc_gaussian(key: chex.PRNGKey) -> None:
-    reprloc_g, state = ReprLoc.GAUSSIAN((3.0, 3.0), (1.0, 1.0))
-    loc = jax.vmap(reprloc_g)(
-        jax.random.split(key, 10),
-        jax.tree_map(lambda a: jnp.tile(a, (10,)), state),
-    )
-    chex.assert_shape(loc, (10, 2))
-    x_mean = jnp.mean(loc[:, 0])
-    y_mean = jnp.mean(loc[:, 1])
-    assert (x_mean - 3) ** 2 < 1.0 and (y_mean - 3) ** 2 < 1.0
+def test_loc_periodic(key: chex.PRNGKey) -> None:
+    points = [(0.0, 0.0), (1.0, 1.0), (2.0, 2.0)]
+    loc_p, state = Locating.PERIODIC(*points)
+    for i in range(10):
+        loc = loc_p(key, state)
+        state = state.increment()
+        print(loc)
+        assert jnp.all(loc == jnp.array(points[i % 3]))
 
 
-def test_reprloc_switching(key: chex.PRNGKey) -> None:
-    initloc_g = InitLoc.GAUSSIAN((3.0, 3.0), (1.0, 1.0))
-    initloc_u = InitLoc.UNIFORM(CircleCoordinate((3.0, 3.0), 3.0))
-    reprloc_s, state = ReprLoc.SWITCHING(10, initloc_g, initloc_u)
-    loc = jax.vmap(reprloc_s)(
+def test_loc_switching(key: chex.PRNGKey) -> None:
+    loc_g, _ = Locating.GAUSSIAN((3.0, 3.0), (1.0, 1.0))
+    loc_u, _ = Locating.UNIFORM(CircleCoordinate((3.0, 3.0), 3.0))
+    loc_s, state = Locating.SWITCHING(10, loc_g, loc_u)
+    loc = jax.vmap(loc_s)(
         jax.random.split(key, 10),
         jax.tree_map(lambda a: jnp.tile(a, (10,)), state),
     )
@@ -101,7 +90,7 @@ def test_reprloc_switching(key: chex.PRNGKey) -> None:
     y_mean = jnp.mean(loc[:, 1])
     assert (x_mean - 3) ** 2 < 1.0 and (y_mean - 3) ** 2 < 1.0
 
-    loc = jax.vmap(reprloc_s)(
+    loc = jax.vmap(loc_s)(
         jax.random.split(key, 10),
         jax.tree_map(lambda a: jnp.tile(a * 10, (10,)), state),
     )
diff --git a/tests/test_observe.py b/tests/test_observe.py
index d6337ded..75890820 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -5,4 +5,3 @@
 
 from emevo.environments.circle_foraging import _make_physics
 from emevo.environments.phyjax2d import Space, StateDict
-from emevo.environments.placement import place_agent, place_food
diff --git a/tests/test_placement.py b/tests/test_placement.py
index d69c2a06..24b74adc 100644
--- a/tests/test_placement.py
+++ b/tests/test_placement.py
@@ -5,7 +5,7 @@
 
 from emevo.environments.circle_foraging import _make_physics
 from emevo.environments.phyjax2d import Space, StateDict
-from emevo.environments.placement import place_agent, place_food
+from emevo.environments.placement import place
 from emevo.environments.locating import CircleCoordinate, Locating
 
 N_MAX_AGENTS = 20
@@ -37,14 +37,15 @@ def test_place_agents(key) -> None:
     n = N_MAX_AGENTS // 2
     keys = jax.random.split(key, n)
     space, stated, coordinate = get_space_and_more()
-    initloc_fn, _ = Locating.UNIFORM(CircleCoordinate((100.0, 100.0), 95.0))
+    initloc_fn, initloc_state = Locating.UNIFORM(CircleCoordinate((100.0, 100.0), 95.0))
     assert stated.circle is not None
     for i, key in enumerate(keys):
-        xy = place_agent(
+        xy = place(
             n_trial=10,
-            agent_radius=AGENT_RADIUS,
+            radius=AGENT_RADIUS,
             coordinate=coordinate,
             loc_fn=initloc_fn,
+            loc_state=initloc_state,
             key=key,
             shaped=space.shaped,
             stated=stated,
@@ -61,8 +62,8 @@ def test_place_agents(key) -> None:
     stated = stated.nested_replace("circle.is_active", is_active)
 
     # test no overwrap each other
-    contact_data = space.check_contacts(stated)
-    assert jnp.all(contact_data.contact.penetration <= 0.0)
+    contact = space.check_contacts(stated)
+    assert jnp.all(contact.penetration <= 0.0)
 
 
 def test_place_foods(key) -> None:
@@ -72,9 +73,9 @@ def test_place_foods(key) -> None:
     reprloc_fn, reprloc_state = Locating.UNIFORM(CircleCoordinate((100.0, 100.0), 95.0))
     assert stated.static_circle is not None
     for i, key in enumerate(keys):
-        xy = place_food(
+        xy = place(
             n_trial=10,
-            food_radius=FOOD_RADIUS,
+            radius=FOOD_RADIUS,
             coordinate=coordinate,
             loc_fn=reprloc_fn,
             loc_state=reprloc_state,
@@ -101,5 +102,5 @@ def test_place_foods(key) -> None:
     stated = stated.nested_replace("static_circle.is_active", is_active)
 
     # test no overwrap each other
-    contact_data = space.check_contacts(stated)
-    assert jnp.all(contact_data.contact.penetration <= 0.0)
+    contact = space.check_contacts(stated)
+    assert jnp.all(contact.penetration <= 0.0)

From 434775b15f065be70cd1a26f7db707aeedaa98a5 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 31 Oct 2023 14:45:22 +0900
Subject: [PATCH 053/337] Start implementing test_observe

---
 smoke-tests/circle_loop.py |  1 +
 tests/test_observe.py      | 45 +++++++++++++++++++++++++++++++++++++-
 2 files changed, 45 insertions(+), 1 deletion(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index e5905443..2585d01c 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -11,6 +11,7 @@
 from numpy.random import PCG64
 from tqdm import tqdm
 
+
 from emevo import make
 
 
diff --git a/tests/test_observe.py b/tests/test_observe.py
index 75890820..abe4f8f6 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -3,5 +3,48 @@
 import jax.numpy as jnp
 import pytest
 
-from emevo.environments.circle_foraging import _make_physics
+from emevo import Env, make
+from emevo.environments.locating import CircleCoordinate, Locating
 from emevo.environments.phyjax2d import Space, StateDict
+from emevo.environments.placement import place
+
+N_MAX_AGENTS = 20
+N_MAX_FOODS = 10
+AGENT_RADIUS = 10
+FOOD_RADIUS = 4
+
+
+@pytest.fixture
+def key() -> chex.PRNGKey:
+    return jax.random.PRNGKey(43)
+
+
+def reset_env() -> Env:
+    env = make(
+        "CircleForaging-v0",
+        env_shape="square",
+        n_max_agents=10,
+        n_initial_agents=5,
+        agent_loc_fn=(
+            "periodic",
+            [40.0, 60.0],
+            [60.0, 90.0],
+            [80.0, 60.0],
+            [100.0, 90.0],
+            [120.0, 60.0],
+        ),
+        food_loc_fn=(
+            "periodic",
+            [60.0, 60.0],
+            [80.0, 90.0],
+            [80.0, 120.0],
+            [100.0, 60.0],
+        ),
+        food_num_fn=("constant", 4),
+        foodloc_interval=20,
+    )
+
+
+def test_observe(key: chex.PRNGKey) -> None:
+    n = N_MAX_AGENTS // 2
+    keys = jax.random.split(key, n)

From f589a892f9fc7bb816c09762390d0917edcf7cea Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 31 Oct 2023 19:04:06 +0900
Subject: [PATCH 054/337] Various bag fixes in _observe_closest

---
 src/emevo/environments/circle_foraging.py | 39 +++++++++----------
 src/emevo/environments/phyjax2d.py        | 39 ++++++++++---------
 tests/test_observe.py                     | 47 ++++++++++++++++++++---
 3 files changed, 81 insertions(+), 44 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 3702dd4a..d9edc7bd 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -18,7 +18,7 @@
     LocatingState,
     SquareCoordinate,
 )
-from emevo.environments.phyjax2d import Position, ShapeDict
+from emevo.environments.phyjax2d import Circle, Position, Raycast, ShapeDict
 from emevo.environments.phyjax2d import Space as Physics
 from emevo.environments.phyjax2d import (
     State,
@@ -168,32 +168,31 @@ def _make_physics(
 
 
 def _observe_closest(
-    offset: float,
     shaped: ShapeDict,
     p1: jax.Array,
     p2: jax.Array,
     stated: StateDict,
-) -> None:
+) -> jax.Array:
     assert shaped.circle is not None and stated.circle is not None
     assert shaped.static_circle is not None and stated.static_circle is not None
     assert shaped.segment is not None and stated.segment is not None
 
-    frac = 1.0 + offset
-    rc = circle_raycast(0.0, frac, p2, p1, shaped.circle, stated.circle)
-    to_c = jnp.clip(jnp.where(rc.hit, rc.fraction, 0.0), a_min=offset)
-    rc = circle_raycast(
-        0.0,
-        frac,
-        p2,
-        p1,
-        shaped.static_circle,
-        stated.static_circle,
+    def cr(shape: Circle, state: State) -> Raycast:
+        return circle_raycast(0.0, 1.0, p1, p2, shape, state)
+
+    rc = cr(shaped.circle, stated.circle)
+    to_c = jnp.where(rc.hit, 1.0 - rc.fraction, -1.0)
+    rc = cr(shaped.static_circle, stated.static_circle)
+    to_sc = jnp.where(rc.hit, 1.0 - rc.fraction, -1.0)
+    rc = segment_raycast(1.0, p1, p2, shaped.segment, stated.segment)
+    to_seg = jnp.where(rc.hit, 1.0 - rc.fraction, -1.0)
+    obs = jnp.concatenate(
+        jax.tree_map(
+            lambda arr: jnp.max(arr, keepdims=True),
+            (to_c, to_sc, to_seg),
+        ),
     )
-    to_sc = jnp.clip(jnp.where(rc.hit, rc.fraction, 0.0), a_min=offset)
-    rc = segment_raycast(frac, p2, p1, shaped.segment, stated.segment)
-    to_seg = jnp.clip(jnp.where(rc.hit, rc.fraction, 0.0), a_min=offset)
-    obs = jnp.stack((to_c, to_sc, to_seg))
-    return jnp.where(obs == jnp.max(obs, axis=-1, keepdims=True), obs, 0.0)
+    return jnp.where(obs == jnp.max(obs, axis=-1, keepdims=True), obs, -1.0)
 
 
 class CircleForaging(Env):
@@ -505,7 +504,7 @@ def _initialize_physics_state(
             "static_circle.p.xy",
             jnp.ones_like(stated.static_circle.p.xy) * -100,
         )
-        keys = jax.random.split(key, self._n_initial_foods + self._n_initial_agents)
+        keys = jax.random.split(key, self._n_initial_agents + self._n_initial_foods)
         agent_failed = 0
         agentloc_state = self._initial_foodloc_state
         for i, key in enumerate(keys[: self._n_initial_agents]):
@@ -524,7 +523,7 @@ def _initialize_physics_state(
 
         food_failed = 0
         foodloc_state = self._initial_foodloc_state
-        for i, key in enumerate(keys[self._n_initial_foods :]):
+        for i, key in enumerate(keys[self._n_initial_agents :]):
             xy = self._place_food(loc_state=foodloc_state, key=key, stated=stated)
             if jnp.all(xy < jnp.inf):
                 stated = stated.nested_replace(
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index d62a5720..e92db77e 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -874,7 +874,7 @@ def apply_bounce(
     contact: Contact,
     helper: ContactHelper,
     solver: VelocitySolver,
-) -> tuple[Velocity, Velocity]:
+) -> tuple[jax.Array, jax.Array]:
     """
     Apply bounce (resititution).
     Suppose that each shape has (N_contact, 1) or (N_contact, 2).
@@ -1077,24 +1077,27 @@ def circle_raycast(
     circle: Circle,
     state: State,
 ) -> Raycast:
-    s = p1 - state.p.xy
+    # Suppose p1 and p2's shape has (2,)
+    s = jnp.expand_dims(p1, axis=0) - state.p.xy  # (N, 2)
     d, length = normalize(p2 - p1)
-    t = -jnp.dot(s, d)
-    c = s + t * d
-    cc = jnp.linalg.norm(c)
+    t = -jnp.dot(s, d)  # (N,)
+
+    @jax.vmap
+    def muld(x: jax.Array) -> jax.Array:
+        return x * d
+
+    c = s + muld(t)  # (N, 2)
+    cc = _vmap_dot(c, c)  # (N, 1)
     rr = (radius + circle.radius) ** 2
-    fraction = t - jnp.sqrt(rr - cc)
-    hitpoint = s + fraction * d
+    fraction = jnp.where(rr >= cc, t - jnp.sqrt(rr - cc), 0.0)
+    hitpoint = s + muld(fraction)
     normal, _ = normalize(hitpoint)
     return Raycast(  # type: ignore
         fraction=fraction / length,
         normal=normal,
         hit=jnp.logical_and(
             cc <= rr,
-            jnp.logical_and(
-                fraction >= 0.0,
-                max_fraction * length >= fraction,
-            ),
+            jnp.logical_and(0.0 <= fraction, fraction <= max_fraction * length),
         ),
     )
 
@@ -1112,20 +1115,20 @@ def segment_raycast(
     e = v2 - v1
     eunit, length = normalize(e)
     normal = _sv_cross(jnp.ones_like(length) * -1, eunit)
-    numerator = jnp.dot(normal, v1 - p1)
-    denominator = jnp.dot(normal, d)
+    numerator = _vmap_dot(normal, v1 - p1)  # (N,)
+    denominator = jnp.dot(normal, d)  # (N,)
     t = numerator / denominator
-    p = p1 + t * d
-    s = jnp.dot(p - v1, eunit)
-    normal = jnp.where(numerator > 0.0, -normal, normal)
+    p = jax.vmap(lambda ti: ti * d + p1)(t)  # (N, 2)
+    s = _vmap_dot(p - v1, eunit)
+    normal = jnp.where(jnp.expand_dims(numerator > 0.0, axis=1), -normal, normal)
     return Raycast(  # type: ignore
         fraction=t,
         normal=normal,
         hit=jnp.logical_and(
             denominator != 0.0,
             jnp.logical_and(
-                jnp.logical_and(t >= 0.0, max_fraction * length >= t),
-                jnp.logical_and(s >= 0.0, length >= s),
+                jnp.logical_and(t >= 0.0, t <= max_fraction),
+                jnp.logical_and(s >= 0.0, s <= length),
             ),
         ),
     )
diff --git a/tests/test_observe.py b/tests/test_observe.py
index abe4f8f6..55163528 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -4,9 +4,7 @@
 import pytest
 
 from emevo import Env, make
-from emevo.environments.locating import CircleCoordinate, Locating
-from emevo.environments.phyjax2d import Space, StateDict
-from emevo.environments.placement import place
+from emevo.environments.circle_foraging import CFState, _observe_closest
 
 N_MAX_AGENTS = 20
 N_MAX_FOODS = 10
@@ -19,7 +17,7 @@ def key() -> chex.PRNGKey:
     return jax.random.PRNGKey(43)
 
 
-def reset_env() -> Env:
+def reset_env(key: chex.PRNGKey) -> tuple[Env, CFState]:
     env = make(
         "CircleForaging-v0",
         env_shape="square",
@@ -42,9 +40,46 @@ def reset_env() -> Env:
         ),
         food_num_fn=("constant", 4),
         foodloc_interval=20,
+        agent_radius=10,
+        food_radius=4,
     )
+    return env, env.reset(key)
 
 
 def test_observe(key: chex.PRNGKey) -> None:
-    n = N_MAX_AGENTS // 2
-    keys = jax.random.split(key, n)
+    env, state = reset_env(key)
+    obs = _observe_closest(
+        env._physics.shaped,
+        jnp.array([40.0, 10.0]),
+        jnp.array([40.0, 30.0]),
+        state.physics,
+    )
+    chex.assert_trees_all_close(obs, jnp.ones(3) * -1)
+    obs = _observe_closest(
+        env._physics.shaped,
+        jnp.array([40.0, 10.0]),
+        jnp.array([40.0, 110.0]),
+        state.physics,
+    )
+    chex.assert_trees_all_close(obs, jnp.array([0.6, -1.0, -1.0]))
+    obs = _observe_closest(
+        env._physics.shaped,
+        jnp.array([60.0, 10.0]),
+        jnp.array([60.0, 110.0]),
+        state.physics,
+    )
+    chex.assert_trees_all_close(obs, jnp.array([-1.0, 0.54, -1.0]))
+    obs = _observe_closest(
+        env._physics.shaped,
+        jnp.array([110.0, 60.0]),
+        jnp.array([90.0, 60.0]),
+        state.physics,
+    )
+    chex.assert_trees_all_close(obs, jnp.array([-1.0, 0.7, -1.0]))
+    obs = _observe_closest(
+        env._physics.shaped,
+        jnp.array([130.0, 60.0]),
+        jnp.array([230.0, 60.0]),
+        state.physics,
+    )
+    chex.assert_trees_all_close(obs, jnp.array([-1.0, -1.0, 0.3]))

From 9eee4c680b0a7bed9f0c44a12c3ee3d180cf4c38 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 1 Nov 2023 10:39:19 +0900
Subject: [PATCH 055/337] Reduce contact information

---
 src/emevo/environments/circle_foraging.py | 33 +++++++++++---
 src/emevo/environments/phyjax2d.py        | 52 +++++++++++++++--------
 2 files changed, 61 insertions(+), 24 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index d9edc7bd..3e82bfd2 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -10,7 +10,7 @@
 import numpy as np
 from jax.typing import ArrayLike
 
-from emevo.env import Env, Profile, Visualizer, init_profile
+from emevo.env import Env, Profile, TimeStep, Visualizer, init_profile
 from emevo.environments.locating import (
     CircleCoordinate,
     Locating,
@@ -26,9 +26,9 @@
     Velocity,
     VelocitySolver,
     circle_raycast,
+    segment_raycast,
 )
-from emevo.environments.phyjax2d import nstep as physics_nstep
-from emevo.environments.phyjax2d import segment_raycast
+from emevo.environments.phyjax2d import step as physics_step
 from emevo.environments.phyjax2d_utils import (
     Color,
     SpaceBuilder,
@@ -62,7 +62,7 @@ def __array__(self) -> jax.Array:
         return jnp.concatenate(
             (
                 self.sensor.ravel(),
-                self.collision,
+                self.collision.ravel(),
                 self.velocity,
                 self.angle,
                 self.angular_velocity,
@@ -195,6 +195,24 @@ def cr(shape: Circle, state: State) -> Raycast:
     return jnp.where(obs == jnp.max(obs, axis=-1, keepdims=True), obs, -1.0)
 
 
+@functools.partial(jax.jit, static_argnums=(0, 1))
+def nstep(
+    n: int,
+    space: Physics,
+    stated: StateDict,
+    solver: VelocitySolver,
+) -> tuple[StateDict, VelocitySolver, jax.Array]:
+    def body(
+        stated_and_solver: tuple[StateDict, VelocitySolver],
+        _zero: jax.Array,
+    ) -> tuple[tuple[StateDict, VelocitySolver], jax.Array]:
+        state, solver, contact = physics_step(space, *stated_and_solver)
+        return (state, solver), contact.penetration >= 0.0
+
+    (state, solver), contacts = jax.lax.scan(body, (stated, solver), jnp.zeros(n))
+    return state, solver, contacts
+
+
 class CircleForaging(Env):
     def __init__(
         self,
@@ -310,7 +328,6 @@ def __init__(
                 shaped=self._physics.shaped,
             )
         )
-        self._nstep = jax.jit(physics_nstep, static_argnums=(0, 1))
 
     @staticmethod
     def _make_food_num_fn(
@@ -395,12 +412,16 @@ def step(self, state: CFState, action: ArrayLike) -> CFState:
         circle = circle.apply_force_local(self._act_p2, f2)
         stated = state.physics.replace(circle=circle)
         # Step physics simulator
-        stated, solver = self._nstep(
+        stated, solver, contacts = nstep(
             self._n_physics_iter,
             self._physics,
             stated,
             state.solver,
         )
+        circle_contacts = self._physics.get_specific_contact(
+            "circle",
+            jnp.max(contacts, axis=0),
+        )
         return state.replace(physics=stated, solver=solver)
 
     def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index e92db77e..6cf4c911 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -503,6 +503,9 @@ def concat(self) -> Shape:
         shapes = [s.to_shape() for s in self.values() if s is not None]
         return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *shapes)
 
+    def n_shapes(self) -> int:
+        return sum([s.batch_size() for s in self.values() if s is not None])
+
     def zeros_state(self) -> StateDict:
         circle = then(self.circle, lambda s: State.zeros(len(s.mass)))
         static_circle = then(self.static_circle, lambda s: State.zeros(len(s.mass)))
@@ -648,6 +651,10 @@ class Space:
     bounce_threshold: float = 1.0
     max_velocity: float = 100.0
     max_angular_velocity: float = 100.0
+    _contact_offset: dict[tuple[str, str], tuple[int, int]] = dataclasses.field(
+        default_factory=dict,
+        init=False,
+    )
     _ci: dict[tuple[str, str], ContactIndices] = dataclasses.field(
         default_factory=dict,
         init=False,
@@ -663,6 +670,7 @@ def __eq__(self, other: Any) -> int:
 
     def __post_init__(self) -> None:
         ci_slided_list = []
+        offset = 0
         for n1, n2 in _CONTACT_FUNCTIONS.keys():
             if self.shaped[n1] is not None and self.shaped[n2] is not None:
                 if n1 == n2:
@@ -670,6 +678,9 @@ def __post_init__(self) -> None:
                 else:
                     ci = _pair_ci(self.shaped[n1], self.shaped[n2])
                 self._ci[n1, n2] = ci
+                offset_start = offset
+                offset += ci.shape1.batch_size()
+                self._contact_offset[n1, n2] = offset_start, offset
                 offset1, offset2 = _offset(self.shaped, n1), _offset(self.shaped, n2)
                 # Add some offset for global indices
                 ci_slided = ContactIndices(
@@ -703,6 +714,26 @@ def n_possible_contacts(self) -> int:
                     n += len1 * len2
         return n
 
+    def get_specific_contact(self, name: str, contact: jax.Array) -> jax.Array:
+        idx1, idx2 = self._ci_total.index1, self._ci_total.index2
+        offset = _offset(self.shaped, name)
+        size = self.shaped[name].batch_size()
+        n = self.shaped.n_shapes()
+        ret = []
+        for n1, n2 in _CONTACT_FUNCTIONS.keys():
+            contact_offset = self._contact_offset.get((n1, n2), None)
+            if contact_offset is not None:
+                has_contact = jnp.zeros(n, dtype=bool)
+                from_, to = contact_offset
+                cont = contact[from_:to]
+                if n1 == name:
+                    has_contact = has_contact.at[idx1[from_:to]].max(cont)
+                if n2 == name:
+                    has_contact = has_contact.at[idx2[from_:to]].max(cont)
+                ret.append(has_contact[offset : offset + size])
+
+        return jnp.stack(ret, axis=1)
+
     def init_solver(self) -> VelocitySolver:
         n = self.n_possible_contacts()
         return VelocitySolver(
@@ -962,7 +993,7 @@ def solve_constraints(
     idx1, idx2 = space._ci_total.index1, space._ci_total.index2
 
     def gather(a: jax.Array, b: jax.Array, orig: jax.Array) -> jax.Array:
-        return orig.at[idx1].add(a).at[idx2].add(b)
+        return orig.at[idx1].add(a, indices_are_sorted=True).at[idx2].add(b)
 
     p1, p2 = p.get_slice(idx1), p.get_slice(idx2)
     v1, v2 = v.get_slice(idx1), v.get_slice(idx2)
@@ -1033,7 +1064,7 @@ def step(
     space: Space,
     stated: StateDict,
     solver: VelocitySolver,
-) -> tuple[StateDict, VelocitySolver]:
+) -> tuple[StateDict, VelocitySolver, Contact]:
     state = update_velocity(space, space.shaped.concat(), stated.concat())
     contact = space.check_contacts(stated.update(state))
     v, p, solver = solve_constraints(
@@ -1044,22 +1075,7 @@ def step(
         contact,
     )
     state = update_position(space, state.replace(v=v, p=p))
-    return stated.update(state), solver
-
-
-def nstep(
-    n: int,
-    space: Space,
-    stated: StateDict,
-    solver: VelocitySolver,
-) -> tuple[StateDict, VelocitySolver]:
-    def wrapped_step(
-        _n_iter: int,
-        stated_and_solver: tuple[StateDict, VelocitySolver],
-    ) -> tuple[StateDict, VelocitySolver]:
-        return step(space, *stated_and_solver)
-
-    return jax.lax.fori_loop(0, n, wrapped_step, (stated, solver))
+    return stated.update(state), solver, contact
 
 
 @chex.dataclass

From 6f2c001fb16ca39df58641133630ccb01b066c36 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 1 Nov 2023 12:00:40 +0900
Subject: [PATCH 056/337] Start implementing sensor

---
 src/emevo/environments/circle_foraging.py | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 3e82bfd2..d320eddc 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -195,6 +195,16 @@ def cr(shape: Circle, state: State) -> Raycast:
     return jnp.where(obs == jnp.max(obs, axis=-1, keepdims=True), obs, -1.0)
 
 
+@functools.partial(jax.jit, static_argnums=(0, 1, 2))
+def get_sensor_obs(
+    shaped: ShapeDict,
+    n_sensors: int,
+    sensor_range: float,
+    stated: StateDict,
+) -> None:
+    assert stated.circle is not None
+
+
 @functools.partial(jax.jit, static_argnums=(0, 1))
 def nstep(
     n: int,
@@ -422,6 +432,7 @@ def step(self, state: CFState, action: ArrayLike) -> CFState:
             "circle",
             jnp.max(contacts, axis=0),
         )
+
         return state.replace(physics=stated, solver=solver)
 
     def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:

From dc050eea8e5459a29a82e7653c2a5fdf86f650ed Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 1 Nov 2023 17:37:15 +0900
Subject: [PATCH 057/337] get_sensor_obs

---
 smoke-tests/circle_loop.py                |  2 +-
 src/emevo/environments/circle_foraging.py | 22 ++++++++++++++++++----
 src/emevo/environments/phyjax2d.py        |  2 +-
 tests/test_observe.py                     | 18 ++++++++++++++++--
 4 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index 2585d01c..ddba7959 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -75,7 +75,7 @@ def main(
     elapsed_list = []
     for i, key in tqdm(zip(range(steps), keys[1:])):
         before = datetime.datetime.now()
-        state = jit_step(state, jit_sample(key))
+        state, _ = jit_step(state, jit_sample(key))
         elapsed = datetime.datetime.now() - before
         if i == 0:
             print(f"Compile: {elapsed.total_seconds()}s")
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index d320eddc..d29a0a02 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -195,14 +195,29 @@ def cr(shape: Circle, state: State) -> Raycast:
     return jnp.where(obs == jnp.max(obs, axis=-1, keepdims=True), obs, -1.0)
 
 
-@functools.partial(jax.jit, static_argnums=(0, 1, 2))
+_vmap_obs = jax.vmap(_observe_closest, in_axes=(None, 0, 0, None))
+
+
 def get_sensor_obs(
     shaped: ShapeDict,
     n_sensors: int,
-    sensor_range: float,
+    sensor_range: tuple[float, float],
+    sensor_length: float,
     stated: StateDict,
 ) -> None:
     assert stated.circle is not None
+    radius = shaped.circle.radius
+    p1 = jnp.stack((jnp.zeros_like(radius), radius), axis=1)  # (N, 2)
+    p1 = jnp.repeat(p1, n_sensors, axis=0)  # (N x M, 2)
+    p2 = p1 + jnp.array([0.0, sensor_length])  # (N x M, 2)
+    sensor_rad = jnp.deg2rad(jnp.linspace(*sensor_range, n_sensors))
+    sensor_p = Position(
+        angle=jax.vmap(lambda x: x + sensor_rad)(stated.circle.p.angle).ravel(),
+        xy=jnp.tile(stated.circle.p.xy, (n_sensors, 1)),
+    )
+    p1 = sensor_p.transform(p1)
+    p2 = sensor_p.transform(p2)
+    return _vmap_obs(shaped, p1, p2, stated)
 
 
 @functools.partial(jax.jit, static_argnums=(0, 1))
@@ -432,8 +447,7 @@ def step(self, state: CFState, action: ArrayLike) -> CFState:
             "circle",
             jnp.max(contacts, axis=0),
         )
-
-        return state.replace(physics=stated, solver=solver)
+        return state.replace(physics=stated, solver=solver), circle_contacts
 
     def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:
         key, activate_key = jax.random.split(state.key)
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 6cf4c911..703698bb 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -122,7 +122,7 @@ def shape(self) -> Any:
 
 
 def _axy(angle: jax.Array, xy: jax.Array) -> jax.Array:
-    return jnp.concatenate((jnp.expand_dims(angle, axis=-1), xy), axis=-1)
+    return jnp.concatenate((jnp.e3xpand_dims(angle, axis=-1), xy), axis=-1)
 
 
 class _PositionLike(Protocol):
diff --git a/tests/test_observe.py b/tests/test_observe.py
index 55163528..824bf779 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -4,7 +4,7 @@
 import pytest
 
 from emevo import Env, make
-from emevo.environments.circle_foraging import CFState, _observe_closest
+from emevo.environments.circle_foraging import CFState, _observe_closest, get_sensor_obs
 
 N_MAX_AGENTS = 20
 N_MAX_FOODS = 10
@@ -46,7 +46,7 @@ def reset_env(key: chex.PRNGKey) -> tuple[Env, CFState]:
     return env, env.reset(key)
 
 
-def test_observe(key: chex.PRNGKey) -> None:
+def test_observe_closest(key: chex.PRNGKey) -> None:
     env, state = reset_env(key)
     obs = _observe_closest(
         env._physics.shaped,
@@ -83,3 +83,17 @@ def test_observe(key: chex.PRNGKey) -> None:
         state.physics,
     )
     chex.assert_trees_all_close(obs, jnp.array([-1.0, -1.0, 0.3]))
+
+
+def test_sensor_obs(key: chex.PRNGKey) -> None:
+    env, state = reset_env(key)
+    sensor_obs = get_sensor_obs(
+        env._physics.shaped,
+        3,
+        (-90, 90),
+        100.0,
+        state.physics,
+    )
+    chex.assert_shape(sensor_obs, (30, 3))
+    # Wall
+    chex.assert_trees_all_close(sensor_obs[0], jnp.array([-1.0, -1.0, 0.3]))

From 560a8897867effe637b0f50db2337e8887f49559 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 2 Nov 2023 12:57:06 +0900
Subject: [PATCH 058/337] test_sensor_obs

---
 src/emevo/environments/circle_foraging.py |  2 +-
 tests/test_observe.py                     | 40 ++++++++++++++++++++---
 2 files changed, 37 insertions(+), 5 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index d29a0a02..e27de706 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -213,7 +213,7 @@ def get_sensor_obs(
     sensor_rad = jnp.deg2rad(jnp.linspace(*sensor_range, n_sensors))
     sensor_p = Position(
         angle=jax.vmap(lambda x: x + sensor_rad)(stated.circle.p.angle).ravel(),
-        xy=jnp.tile(stated.circle.p.xy, (n_sensors, 1)),
+        xy=jnp.repeat(stated.circle.p.xy, n_sensors, axis=0),
     )
     p1 = sensor_p.transform(p1)
     p2 = sensor_p.transform(p2)
diff --git a/tests/test_observe.py b/tests/test_observe.py
index 824bf779..9f84bb48 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -18,6 +18,9 @@ def key() -> chex.PRNGKey:
 
 
 def reset_env(key: chex.PRNGKey) -> tuple[Env, CFState]:
+    #     x
+    #   O x O
+    # O x O  O  (O: agent, x: food)
     env = make(
         "CircleForaging-v0",
         env_shape="square",
@@ -36,9 +39,8 @@ def reset_env(key: chex.PRNGKey) -> tuple[Env, CFState]:
             [60.0, 60.0],
             [80.0, 90.0],
             [80.0, 120.0],
-            [100.0, 60.0],
         ),
-        food_num_fn=("constant", 4),
+        food_num_fn=("constant", 3),
         foodloc_interval=20,
         agent_radius=10,
         food_radius=4,
@@ -95,5 +97,35 @@ def test_sensor_obs(key: chex.PRNGKey) -> None:
         state.physics,
     )
     chex.assert_shape(sensor_obs, (30, 3))
-    # Wall
-    chex.assert_trees_all_close(sensor_obs[0], jnp.array([-1.0, -1.0, 0.3]))
+    # Food is to the right/left of the circle
+    chex.assert_trees_all_close(
+        sensor_obs[0],
+        sensor_obs[3],
+        sensor_obs[8],
+        sensor_obs[11],
+        jnp.array([-1.0, 0.94, -1.0]),
+    )
+    # Food is above the circle
+    chex.assert_trees_all_close(sensor_obs[7], jnp.array([-1.0, 0.84, -1.0]))
+    # They can see each other
+    chex.assert_trees_all_close(
+        sensor_obs[6],
+        sensor_obs[14],
+        jnp.array([0.8, -1.0, -1.0]),
+    )
+    # Walls
+    chex.assert_trees_all_close(sensor_obs[2], jnp.array([-1.0, -1.0, 0.7]))
+    chex.assert_trees_all_close(sensor_obs[5], jnp.array([-1.0, -1.0, 0.5]))
+    chex.assert_trees_all_close(sensor_obs[9], jnp.array([-1.0, -1.0, 0.1]))
+    chex.assert_trees_all_close(
+        sensor_obs[4],
+        sensor_obs[10],
+        jnp.array([-1.0, -1.0, 0.0]),
+    )
+    chex.assert_trees_all_close(sensor_obs[12], jnp.array([-1.0, -1.0, 0.3]))
+    # Nothing
+    chex.assert_trees_all_close(
+        sensor_obs[1],
+        sensor_obs[13],
+        jnp.array([-1.0, -1.0, -1.0]),
+    )

From 8434e87eaf023f614e2829922fd3f6a72d18fdf4 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 3 Nov 2023 14:07:34 +0900
Subject: [PATCH 059/337] get_contact_mat

---
 src/emevo/env.py                              |  20 ++-
 src/emevo/environments/circle_foraging.py     |  59 ++++++---
 .../{locating.py => env_utils.py}             | 122 +++++++++++++++++-
 src/emevo/environments/phyjax2d.py            | 102 +++++----------
 src/emevo/environments/placement.py           |  39 ------
 src/emevo/environments/reproduction.py        |  99 --------------
 tests/test_env_utils.py                       |   5 +-
 tests/test_observe.py                         |  11 +-
 tests/test_placement.py                       |   3 +-
 9 files changed, 217 insertions(+), 243 deletions(-)
 rename src/emevo/environments/{locating.py => env_utils.py} (59%)
 delete mode 100644 src/emevo/environments/placement.py
 delete mode 100644 src/emevo/environments/reproduction.py

diff --git a/src/emevo/env.py b/src/emevo/env.py
index 22e67cb0..b2ca2de6 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import abc
+import dataclasses
 from typing import Any, Generic, Protocol, TypeVar
 
 import chex
@@ -10,7 +11,7 @@
 from jax.typing import ArrayLike
 
 from emevo.spaces import Space
-from emevo.types import Index, PyTree
+from emevo.types import Index
 from emevo.visualizer import Visualizer
 
 Self = Any
@@ -80,14 +81,21 @@ def is_extinct(self) -> bool:
 
 STATE = TypeVar("STATE", bound="StateProtocol")
 
-OBS = TypeVar("OBS")
+
+class ObsProtocol(Protocol):
+    """Each state should have PRNG key"""
+
+    def as_array(self) -> jax.Array:
+        ...
+
+OBS = TypeVar("OBS", bound="ObsProtocol")
 
 
 @chex.dataclass
-class TimeStep:
+class TimeStep(Generic[OBS]):
     encount: jax.Array | None
-    obs: PyTree
-    info: dict[str, Any]
+    obs: OBS
+    info: dict[str, Any] = dataclasses.field(default_factory=dict)
 
 
 class Env(abc.ABC, Generic[STATE, OBS]):
@@ -106,7 +114,7 @@ def reset(self, key: chex.PRNGKey) -> STATE:
         pass
 
     @abc.abstractmethod
-    def step(self, state: STATE, action: ArrayLike) -> tuple[STATE, TimeStep]:
+    def step(self, state: STATE, action: ArrayLike) -> tuple[STATE, TimeStep[OBS]]:
         """
         Step the simulator by 1-step, taking the state and actions from each body.
         Returns the next state and all encounts.
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index e27de706..2cfc0a2b 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -11,12 +11,16 @@
 from jax.typing import ArrayLike
 
 from emevo.env import Env, Profile, TimeStep, Visualizer, init_profile
-from emevo.environments.locating import (
+from emevo.environments.env_utils import (
     CircleCoordinate,
+    FoodNumState,
     Locating,
     LocatingFn,
     LocatingState,
+    ReprNum,
+    ReprNumFn,
     SquareCoordinate,
+    place,
 )
 from emevo.environments.phyjax2d import Circle, Position, Raycast, ShapeDict
 from emevo.environments.phyjax2d import Space as Physics
@@ -35,8 +39,6 @@
     make_approx_circle,
     make_square,
 )
-from emevo.environments.placement import place
-from emevo.environments.reproduction import FoodNumState, ReprNum, ReprNumFn
 from emevo.spaces import BoxSpace, NamedTupleSpace
 from emevo.types import Index
 from emevo.vec2d import Vec2d
@@ -56,18 +58,17 @@ class CFObs(NamedTuple):
     velocity: jax.Array
     angle: jax.Array
     angular_velocity: jax.Array
-    energy: jax.Array
 
-    def __array__(self) -> jax.Array:
+    def as_array(self) -> jax.Array:
         return jnp.concatenate(
             (
-                self.sensor.ravel(),
+                self.sensor.reshape(self.sensor.shape[0], -1),
                 self.collision.ravel(),
                 self.velocity,
                 self.angle,
                 self.angular_velocity,
-                self.energy,
-            )
+            ),
+            axis=1,
         )
 
 
@@ -324,8 +325,9 @@ def __init__(
             velocity=BoxSpace(low=-MAX_VELOCITY, high=MAX_VELOCITY, shape=(N, 2)),
             angle=BoxSpace(low=-2 * np.pi, high=2 * np.pi, shape=(N,)),
             angular_velocity=BoxSpace(low=-np.pi / 10, high=np.pi / 10, shape=(N,)),
-            energy=BoxSpace(low=0.0, high=50.0, shape=(N,)),
         )
+        # Obs
+        self._n_sensors = n_agent_sensors
         # Some cached constants
         self._invisible_xy = jnp.array([-100.0, -100.0], dtype=jnp.float32)
         act_p1 = Vec2d(0, agent_radius).rotated(np.pi * 0.75)
@@ -353,6 +355,15 @@ def __init__(
                 shaped=self._physics.shaped,
             )
         )
+        self._sensor_obs = jax.jit(
+            functools.partial(
+                get_sensor_obs,
+                shaped=self._physics.shaped,
+                n_sensors=n_agent_sensors,
+                sensor_range=sensor_range,
+                sensor_length=sensor_length,
+            )
+        )
 
     @staticmethod
     def _make_food_num_fn(
@@ -426,7 +437,11 @@ def set_food_loc_fn(self, food_loc_fn: str | tuple | LocatingFn) -> None:
     def set_agent_loc_fn(self, agent_loc_fn: str | tuple | LocatingFn) -> None:
         self._agent_loc_fn = self._make_agent_loc_fn(agent_loc_fn)
 
-    def step(self, state: CFState, action: ArrayLike) -> CFState:
+    def step(
+        self,
+        state: CFState,
+        action: ArrayLike,
+    ) -> tuple[CFState, TimeStep[CFObs]]:
         # Add force
         act = self.act_space.clip(jnp.array(action))
         f1, f2 = act[:, 0], act[:, 1]
@@ -443,11 +458,19 @@ def step(self, state: CFState, action: ArrayLike) -> CFState:
             stated,
             state.solver,
         )
-        circle_contacts = self._physics.get_specific_contact(
-            "circle",
-            jnp.max(contacts, axis=0),
+        contacts = jnp.max(contacts, axis=0)
+        circle_contacts = self._physics.get_specific_contact("circle", contacts)
+        sensor_obs = self._sensor_obs(stated=stated)
+        obs = CFObs(
+            sensor=sensor_obs.reshape(-1, self._n_sensors, 3),
+            collision=circle_contacts,
+            angle=stated.circle.p.angle,
+            velocity=stated.circle.v.xy,
+            angular_velocity=stated.circle.v.angle,
         )
-        return state.replace(physics=stated, solver=solver), circle_contacts
+        encount = self._physics.get_contact_mat("circle", "circle", contacts)
+        timestep = TimeStep(encount=encount, obs=obs)
+        return state.replace(physics=stated, solver=solver), timestep
 
     def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:
         key, activate_key = jax.random.split(state.key)
@@ -460,7 +483,7 @@ def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool
         xy = self._place_agent(key=activate_key, stated=state.physics)
         ok = jnp.logical_and(index >= 0, jnp.all(xy < jnp.inf))
 
-        def success() -> tuple[CFState, bool]:
+        def success(state: CFState) -> tuple[CFState, bool]:
             circle_xy = state.physics.circle.p.xy.at[index].set(xy)
             circle_angle = state.physics.circle.p.angle.at[index].set(0.0)
             p = Position(angle=circle_angle, xy=circle_xy)
@@ -481,7 +504,7 @@ def success() -> tuple[CFState, bool]:
             )
             return new_state, True
 
-        def failure() -> tuple[CFState, bool]:
+        def failure(state: CFState) -> tuple[CFState, bool]:
             return state.replace(key=key), False
 
         return jax.lax.cond(ok, success, failure)
@@ -489,7 +512,7 @@ def failure() -> tuple[CFState, bool]:
     def deactivate(self, state: CFState, index: Index) -> tuple[CFState, bool]:
         ok = state.profile.is_active()[index]
 
-        def success() -> tuple[CFState, bool]:
+        def success(state: CFState) -> tuple[CFState, bool]:
             p_xy = state.physics.circle.p.xy.at[index].set(self._invisible_xy)
             p = state.physics.circle.p.replace(xy=p_xy)
             v_xy = state.physics.circle.v.xy.at[index].set(jnp.zeros(2))
@@ -501,7 +524,7 @@ def success() -> tuple[CFState, bool]:
             profile = state.profile.deactivate(index)
             return state.replace(physics=physics, profile=profile), True
 
-        return jax.lax.cond(ok, success, lambda: (state, False))
+        return jax.lax.cond(ok, success, lambda state: (state, False))
 
     def reset(self, key: chex.PRNGKey) -> CFState:
         state_key, init_key = jax.random.split(key)
diff --git a/src/emevo/environments/locating.py b/src/emevo/environments/env_utils.py
similarity index 59%
rename from src/emevo/environments/locating.py
rename to src/emevo/environments/env_utils.py
index af4d2ad8..6da6b104 100644
--- a/src/emevo/environments/locating.py
+++ b/src/emevo/environments/env_utils.py
@@ -1,8 +1,8 @@
+"""Place agent and food"""
 from __future__ import annotations
 
 import dataclasses
 import enum
-from collections.abc import Iterable
 from typing import Any, Callable, Protocol
 
 import chex
@@ -10,9 +10,98 @@
 import jax.numpy as jnp
 from jax.typing import ArrayLike
 
+from emevo.environments.phyjax2d import ShapeDict, StateDict
+from emevo.environments.phyjax2d_utils import circle_overwrap
+
 Self = Any
 
 
+@chex.dataclass
+class FoodNumState:
+    current: jax.Array
+    internal: jax.Array
+
+    def appears(self) -> jax.Array:
+        return (self.internal - self.current) >= 1.0
+
+    def eaten(self, n: int | jax.Array) -> Self:
+        return self.replace(current=self.current - n, internal=self.internal - n)
+
+    def recover(self, n: int | jax.Array = 1) -> Self:
+        return self.replace(current=self.current + n)
+
+
+class ReprNumFn(Protocol):
+    initial: int
+
+    def __call__(self, state: FoodNumState) -> FoodNumState:
+        ...
+
+
+@dataclasses.dataclass(frozen=True)
+class ReprNumConstant:
+    initial: int
+
+    def __call__(self, state: FoodNumState) -> FoodNumState:
+        internal = jnp.fmax(state.current, state.internal)
+        diff = jnp.clip(self.initial - state.current, a_min=0)
+        state = state.replace(internal=internal + diff)
+        return state
+
+
+@dataclasses.dataclass(frozen=True)
+class ReprNumLinear:
+    initial: int
+    dn_dt: float
+
+    def __call__(self, state: FoodNumState) -> FoodNumState:
+        # Increase the number of foods by dn_dt
+        internal = jnp.fmax(state.current, state.internal)
+        internal = jnp.clip(internal + self.dn_dt, a_max=float(self.initial))
+        return state.replace(internal=internal)
+
+
+@dataclasses.dataclass(frozen=True)
+class ReprNumLogistic:
+    initial: int
+    growth_rate: float
+    capacity: float
+
+    def __call__(self, state: FoodNumState) -> FoodNumState:
+        internal = jnp.fmax(state.current, state.internal)
+        dn_dt = self.growth_rate * internal * (1 - internal / self.capacity)
+        return state.replace(internal=internal + dn_dt)
+
+
+class ReprNum(str, enum.Enum):
+    """Methods to determine the number of foods reproduced."""
+
+    CONSTANT = "constant"
+    LINEAR = "linear"
+    LOGISTIC = "logistic"
+
+    def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn, FoodNumState]:
+        if len(args) > 0:
+            initial = args[0]
+        elif "initial" in kwargs:
+            initial = kwargs["initial"]
+        else:
+            raise ValueError("'initial' is required for all ReprNum functions")
+        state = FoodNumState(  # type: ignore
+            current=jnp.array(int(initial), dtype=jnp.int32),
+            internal=jnp.array(float(initial), dtype=jnp.float32),
+        )
+        if self is ReprNum.CONSTANT:
+            fn = ReprNumConstant(*args, **kwargs)
+        elif self is ReprNum.LINEAR:
+            fn = ReprNumLinear(*args, **kwargs)
+        elif self is ReprNum.LOGISTIC:
+            fn = ReprNumLogistic(*args, **kwargs)
+        else:
+            raise AssertionError("Unreachable")
+        return fn, state
+
+
 class Coordinate(Protocol):
     def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]:
         ...
@@ -171,3 +260,34 @@ def __init__(
     def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
         index = (state.n_produced // self._interval) % self._n
         return jax.lax.switch(index, self._locfn_list, key, state)
+
+
+_vmap_co = jax.vmap(circle_overwrap, in_axes=(None, None, 0, None))
+
+
+def place(
+    n_trial: int,
+    radius: float,
+    coordinate: Coordinate,
+    loc_fn: LocatingFn,
+    loc_state: LocatingState,
+    key: chex.PRNGKey,
+    shaped: ShapeDict,
+    stated: StateDict,
+) -> jax.Array:
+    """Returns `[inf, inf]` if it fails"""
+    keys = jax.random.split(key, n_trial)
+    vmap_loc_fn = jax.vmap(loc_fn, in_axes=(0, None))
+    locations = vmap_loc_fn(keys, loc_state)
+    contains_fn = jax.vmap(coordinate.contains_circle, in_axes=(0, None))
+    ok = jnp.logical_and(
+        contains_fn(locations, radius),
+        jnp.logical_not(_vmap_co(shaped, stated, locations, radius)),
+    )
+    (ok_idx,) = jnp.nonzero(ok, size=1, fill_value=-1)
+    ok_idx = ok_idx[0]
+    return jax.lax.cond(
+        ok_idx < 0,
+        lambda: jnp.ones(2) * jnp.inf,
+        lambda: locations[ok_idx],
+    )
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 703698bb..6937f6e9 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -25,52 +25,6 @@ def normalize(x: jax.Array, axis: Axis | None = None) -> tuple[jax.Array, jax.Ar
     return n, norm
 
 
-def tree_map2(
-    f: Callable[..., Any],
-    tree: Any,
-    *rest: Any,
-    is_leaf: Callable[[Any], bool] | None = None,
-) -> tuple[Any, Any]:
-    """Same as tree_map, but returns a tuple"""
-    leaves, treedef = jax.tree_util.tree_flatten(tree, is_leaf)
-    all_leaves = [leaves] + [treedef.flatten_up_to(r) for r in rest]
-    result = [f(*xs) for xs in zip(*all_leaves)]
-    a = treedef.unflatten([elem[0] for elem in result])
-    b = treedef.unflatten([elem[1] for elem in result])
-    return a, b
-
-
-def generate_self_pairs(x: jax.Array) -> tuple[jax.Array, jax.Array]:
-    """Returns two arrays that iterate over all combination of elements in x and y."""
-    # x.shape[0] > 1
-    chex.assert_axis_dimension_gt(x, 0, 1)
-    n = x.shape[0]
-    # (a, a, a, b, b, c)
-    outer_loop = jnp.repeat(
-        x,
-        jnp.arange(n - 1, -1, -1),
-        axis=0,
-        total_repeat_length=n * (n - 1) // 2,
-    )
-    # (b, c, d, c, d, d)
-    inner_loop = jnp.concatenate([x[i:] for i in range(1, len(x))])
-    return outer_loop, inner_loop
-
-
-def _pair_outer(x: jax.Array, reps: int) -> jax.Array:
-    return jnp.repeat(x, reps, axis=0, total_repeat_length=x.shape[0] * reps)
-
-
-def _pair_inner(x: jax.Array, reps: int) -> jax.Array:
-    return jnp.tile(x, (reps,) + (1,) * (x.ndim - 1))
-
-
-def generate_pairs(x: jax.Array, y: jax.Array) -> tuple[jax.Array, jax.Array]:
-    """Returns two arrays that iterate over all combination of elements in x and y"""
-    xlen, ylen = x.shape[0], y.shape[0]
-    return _pair_outer(x, ylen), _pair_inner(y, xlen)
-
-
 class PyTreeOps:
     def __add__(self, o: Any) -> Self:
         if o.__class__ is self.__class__:
@@ -93,6 +47,7 @@ def __neg__(self) -> Self:
     def __truediv__(self, o: float | jax.Array) -> Self:
         return jax.tree_map(lambda x: x / o, self)
 
+    @jax.jit
     def get_slice(
         self,
         index: int | Sequence[int] | Sequence[bool] | jax.Array,
@@ -122,7 +77,7 @@ def shape(self) -> Any:
 
 
 def _axy(angle: jax.Array, xy: jax.Array) -> jax.Array:
-    return jnp.concatenate((jnp.e3xpand_dims(angle, axis=-1), xy), axis=-1)
+    return jnp.concatenate((jnp.expand_dims(angle, axis=-1), xy), axis=-1)
 
 
 class _PositionLike(Protocol):
@@ -540,32 +495,32 @@ class ContactIndices:
     index2: jax.Array
 
 
-# These fuctions are used in __post_init__ so need to jit
-_jitted_self_pairs = jax.jit(generate_self_pairs)
-_jitted_pairs = jax.jit(generate_pairs)
-_jitted_pair_outer = jax.jit(_pair_outer, static_argnums=(1,))
-_jitted_pair_inner = jax.jit(_pair_inner, static_argnums=(1,))
-
-
 def _self_ci(shape: Shape) -> ContactIndices:
-    shape1, shape2 = tree_map2(_jitted_self_pairs, shape)
-    index1, index2 = _jitted_self_pairs(jnp.arange(shape.mass.shape[0]))
+    n = shape.batch_size()
+    index1, index2 = jax.jit(jnp.triu_indices, static_argnums=(0, 1))(n, 1)
     return ContactIndices(
-        shape1=shape1,
-        shape2=shape2,
+        shape1=shape.get_slice(index1),
+        shape2=shape.get_slice(index2),
         index1=index1,
         index2=index2,
     )
 
 
 def _pair_ci(shape1: Shape, shape2: Shape) -> ContactIndices:
-    n1, n2 = shape1.mass.shape[0], shape2.mass.shape[0]
-    s1_extended = jax.tree_map(functools.partial(_jitted_pair_outer, reps=n2), shape1)
-    s2_extended = jax.tree_map(functools.partial(_jitted_pair_inner, reps=n1), shape2)
-    index1, index2 = _jitted_pairs(jnp.arange(n1), jnp.arange(n2))
+    @functools.partial(jax.jit, static_argnums=(1,))
+    def pair_outer(x: jax.Array, reps: int) -> jax.Array:
+        return jnp.repeat(x, reps, axis=0, total_repeat_length=x.shape[0] * reps)
+
+    @functools.partial(jax.jit, static_argnums=(1,))
+    def pair_inner(x: jax.Array, reps: int) -> jax.Array:
+        return jnp.tile(x, (reps,) + (1,) * (x.ndim - 1))
+
+    n1, n2 = shape1.batch_size(), shape2.batch_size()
+    index1 = pair_outer(jnp.arange(n1), reps=n2)
+    index2 = pair_inner(jnp.arange(n2), reps=n1)
     return ContactIndices(
-        shape1=s1_extended,
-        shape2=s2_extended,
+        shape1=shape1.get_slice(index1),
+        shape2=shape2.get_slice(index2),
         index1=index1,
         index2=index2,
     )
@@ -719,7 +674,7 @@ def get_specific_contact(self, name: str, contact: jax.Array) -> jax.Array:
         offset = _offset(self.shaped, name)
         size = self.shaped[name].batch_size()
         n = self.shaped.n_shapes()
-        ret = []
+        has_contact_list = []
         for n1, n2 in _CONTACT_FUNCTIONS.keys():
             contact_offset = self._contact_offset.get((n1, n2), None)
             if contact_offset is not None:
@@ -730,9 +685,20 @@ def get_specific_contact(self, name: str, contact: jax.Array) -> jax.Array:
                     has_contact = has_contact.at[idx1[from_:to]].max(cont)
                 if n2 == name:
                     has_contact = has_contact.at[idx2[from_:to]].max(cont)
-                ret.append(has_contact[offset : offset + size])
-
-        return jnp.stack(ret, axis=1)
+                has_contact_list.append(has_contact[offset : offset + size])
+        return jnp.stack(has_contact_list, axis=1)
+
+    def get_contact_mat(self, n1: str, n2: str, contact: jax.Array) -> jax.Array:
+        contact_offset = self._contact_offset.get((n1, n2), None)
+        assert contact_offset is not None
+        from_, to = contact_offset
+        size1, size2 = self.shaped[n1].batch_size(), self.shaped[n2].batch_size()
+        if n1 == n2:
+            ret = jnp.zeros((size1, size1), dtype=bool)
+            idx1, idx2 = jnp.triu_indices(size1, k=1)
+            return ret.at[idx1, idx2].set(contact[from_:to])
+        else:
+            return contact[from_:to].reshape(size1, size2)
 
     def init_solver(self) -> VelocitySolver:
         n = self.n_possible_contacts()
diff --git a/src/emevo/environments/placement.py b/src/emevo/environments/placement.py
deleted file mode 100644
index 84313d69..00000000
--- a/src/emevo/environments/placement.py
+++ /dev/null
@@ -1,39 +0,0 @@
-"""Place agent and food"""
-
-import chex
-import jax
-import jax.numpy as jnp
-
-from emevo.environments.locating import Coordinate, LocatingFn, LocatingState
-from emevo.environments.phyjax2d import ShapeDict, StateDict
-from emevo.environments.phyjax2d_utils import circle_overwrap
-
-_vmap_co = jax.vmap(circle_overwrap, in_axes=(None, None, 0, None))
-
-
-def place(
-    n_trial: int,
-    radius: float,
-    coordinate: Coordinate,
-    loc_fn: LocatingFn,
-    loc_state: LocatingState,
-    key: chex.PRNGKey,
-    shaped: ShapeDict,
-    stated: StateDict,
-) -> jax.Array:
-    """Returns `[inf, inf]` if it fails"""
-    keys = jax.random.split(key, n_trial)
-    vmap_loc_fn = jax.vmap(loc_fn, in_axes=(0, None))
-    locations = vmap_loc_fn(keys, loc_state)
-    contains_fn = jax.vmap(coordinate.contains_circle, in_axes=(0, None))
-    ok = jnp.logical_and(
-        contains_fn(locations, radius),
-        jnp.logical_not(_vmap_co(shaped, stated, locations, radius)),
-    )
-    (ok_idx,) = jnp.nonzero(ok, size=1, fill_value=-1)
-    ok_idx = ok_idx[0]
-    return jax.lax.cond(
-        ok_idx < 0,
-        lambda: jnp.ones(2) * jnp.inf,
-        lambda: locations[ok_idx],
-    )
diff --git a/src/emevo/environments/reproduction.py b/src/emevo/environments/reproduction.py
deleted file mode 100644
index 324337ce..00000000
--- a/src/emevo/environments/reproduction.py
+++ /dev/null
@@ -1,99 +0,0 @@
-""" Utility functions to write food reproduction code in foraging environments.
-"""
-from __future__ import annotations
-
-import dataclasses
-import enum
-from typing import Any, Protocol
-
-import chex
-import jax
-import jax.numpy as jnp
-
-Self = Any
-
-
-@chex.dataclass
-class FoodNumState:
-    current: jax.Array
-    internal: jax.Array
-
-    def appears(self) -> jax.Array:
-        return (self.internal - self.current) >= 1.0
-
-    def eaten(self, n: int | jax.Array) -> Self:
-        return self.replace(current=self.current - n, internal=self.internal - n)
-
-    def recover(self, n: int | jax.Array = 1) -> Self:
-        return self.replace(current=self.current + n)
-
-
-class ReprNumFn(Protocol):
-    initial: int
-
-    def __call__(self, state: FoodNumState) -> FoodNumState:
-        ...
-
-
-@dataclasses.dataclass(frozen=True)
-class ReprNumConstant:
-    initial: int
-
-    def __call__(self, state: FoodNumState) -> FoodNumState:
-        internal = jnp.fmax(state.current, state.internal)
-        diff = jnp.clip(self.initial - state.current, a_min=0)
-        state = state.replace(internal=internal + diff)
-        return state
-
-
-@dataclasses.dataclass(frozen=True)
-class ReprNumLinear:
-    initial: int
-    dn_dt: float
-
-    def __call__(self, state: FoodNumState) -> FoodNumState:
-        # Increase the number of foods by dn_dt
-        internal = jnp.fmax(state.current, state.internal)
-        internal = jnp.clip(internal + self.dn_dt, a_max=float(self.initial))
-        return state.replace(internal=internal)
-
-
-@dataclasses.dataclass(frozen=True)
-class ReprNumLogistic:
-    initial: int
-    growth_rate: float
-    capacity: float
-
-    def __call__(self, state: FoodNumState) -> FoodNumState:
-        internal = jnp.fmax(state.current, state.internal)
-        dn_dt = self.growth_rate * internal * (1 - internal / self.capacity)
-        return state.replace(internal=internal + dn_dt)
-
-
-class ReprNum(str, enum.Enum):
-    """Methods to determine the number of foods reproduced."""
-
-    CONSTANT = "constant"
-    LINEAR = "linear"
-    LOGISTIC = "logistic"
-
-    def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn, FoodNumState]:
-        if len(args) > 0:
-            initial = args[0]
-        elif "initial" in kwargs:
-            initial = kwargs["initial"]
-        else:
-            raise ValueError("'initial' is required for all ReprNum functions")
-        state = FoodNumState(  # type: ignore
-            current=jnp.array(int(initial), dtype=jnp.int32),
-            internal=jnp.array(float(initial), dtype=jnp.float32),
-        )
-        if self is ReprNum.CONSTANT:
-            fn = ReprNumConstant(*args, **kwargs)
-        elif self is ReprNum.LINEAR:
-            fn = ReprNumLinear(*args, **kwargs)
-        elif self is ReprNum.LOGISTIC:
-            fn = ReprNumLogistic(*args, **kwargs)
-        else:
-            raise AssertionError("Unreachable")
-        return fn, state
diff --git a/tests/test_env_utils.py b/tests/test_env_utils.py
index fa4df813..8b17f78b 100644
--- a/tests/test_env_utils.py
+++ b/tests/test_env_utils.py
@@ -3,11 +3,10 @@
 import jax.numpy as jnp
 import pytest
 
-from emevo.environments.reproduction import  ReprNum
-from emevo.environments.locating import (
+from emevo.environments.env_utils import (
     CircleCoordinate,
     Locating,
-    LocatingFn,
+    ReprNum,
     SquareCoordinate,
 )
 
diff --git a/tests/test_observe.py b/tests/test_observe.py
index 9f84bb48..85fcfb20 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -71,13 +71,6 @@ def test_observe_closest(key: chex.PRNGKey) -> None:
         state.physics,
     )
     chex.assert_trees_all_close(obs, jnp.array([-1.0, 0.54, -1.0]))
-    obs = _observe_closest(
-        env._physics.shaped,
-        jnp.array([110.0, 60.0]),
-        jnp.array([90.0, 60.0]),
-        state.physics,
-    )
-    chex.assert_trees_all_close(obs, jnp.array([-1.0, 0.7, -1.0]))
     obs = _observe_closest(
         env._physics.shaped,
         jnp.array([130.0, 60.0]),
@@ -129,3 +122,7 @@ def test_sensor_obs(key: chex.PRNGKey) -> None:
         sensor_obs[13],
         jnp.array([-1.0, -1.0, -1.0]),
     )
+
+
+def test_encount(key: chex.PRNGKey) -> None:
+    env, state = reset_env(key)
diff --git a/tests/test_placement.py b/tests/test_placement.py
index 24b74adc..8fe0922d 100644
--- a/tests/test_placement.py
+++ b/tests/test_placement.py
@@ -4,9 +4,8 @@
 import pytest
 
 from emevo.environments.circle_foraging import _make_physics
+from emevo.environments.env_utils import CircleCoordinate, Locating, place
 from emevo.environments.phyjax2d import Space, StateDict
-from emevo.environments.placement import place
-from emevo.environments.locating import CircleCoordinate, Locating
 
 N_MAX_AGENTS = 20
 N_MAX_FOODS = 10

From 34d448870d82fa119f09d5c8ef49e2c7cbaf34cb Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 3 Nov 2023 14:32:24 +0900
Subject: [PATCH 060/337] test_encount

---
 tests/test_observe.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/tests/test_observe.py b/tests/test_observe.py
index 85fcfb20..3263d0fe 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -126,3 +126,21 @@ def test_sensor_obs(key: chex.PRNGKey) -> None:
 
 def test_encount(key: chex.PRNGKey) -> None:
     env, state = reset_env(key)
+    act1 = jnp.zeros((10, 2)).at[4, 1].set(1.0).at[2, 0].set(1.0)
+    step = jax.jit(env.step)
+    while True:
+        state, ts = step(state, act1)
+        assert jnp.all(jnp.logical_not(ts.encount))
+        if state.physics.circle.p.angle[4] >= jnp.pi * 0.5:
+            break
+    act2 = jnp.zeros((10, 2)).at[4].set(1.0).at[2].set(1.0)
+    for i in range(1000):
+        state, ts = step(state, act2)
+        p1 = state.physics.circle.p.xy[2]
+        p2 = state.physics.circle.p.xy[4]
+        if jnp.linalg.norm(p1 - p2) <= 20.0:
+            assert bool(ts.encount[2, 4])
+            break
+        else:
+            assert jnp.all(jnp.logical_not(ts.encount)), f"P1: {p1}, P2: {p2}"
+    assert i < 999

From 8447016d9af7b734f770a1115c31a5e98951f584 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 3 Nov 2023 15:11:04 +0900
Subject: [PATCH 061/337] Remove pymunk env

---
 src/emevo/environments/__init__.py            |   3 -
 .../environments/pymunk_envs/__init__.py      |   1 -
 src/emevo/environments/pymunk_envs/circle.py  | 626 ------------------
 .../environments/pymunk_envs/pygame_vis.py    |  43 --
 .../environments/pymunk_envs/pymunk_env.py    |  19 -
 .../environments/pymunk_envs/pymunk_utils.py  | 315 ---------
 6 files changed, 1007 deletions(-)
 delete mode 100644 src/emevo/environments/pymunk_envs/__init__.py
 delete mode 100644 src/emevo/environments/pymunk_envs/circle.py
 delete mode 100644 src/emevo/environments/pymunk_envs/pygame_vis.py
 delete mode 100644 src/emevo/environments/pymunk_envs/pymunk_env.py
 delete mode 100644 src/emevo/environments/pymunk_envs/pymunk_utils.py

diff --git a/src/emevo/environments/__init__.py b/src/emevo/environments/__init__.py
index 27b317df..e9e57352 100644
--- a/src/emevo/environments/__init__.py
+++ b/src/emevo/environments/__init__.py
@@ -1,9 +1,6 @@
 """ Implementation of registry and built-in emevo environments.
 """
 
-
-# from emevo.environments.pymunk_envs import circle
-# from emevo.environments.pymunk_envs.circle import CFBody, CFObs, CircleForaging
 from emevo.environments.registry import description, make, register
 from emevo.environments.circle_foraging import CircleForaging
 
diff --git a/src/emevo/environments/pymunk_envs/__init__.py b/src/emevo/environments/pymunk_envs/__init__.py
deleted file mode 100644
index 2c1f9f45..00000000
--- a/src/emevo/environments/pymunk_envs/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Environments based on PyMunk"""
diff --git a/src/emevo/environments/pymunk_envs/circle.py b/src/emevo/environments/pymunk_envs/circle.py
deleted file mode 100644
index f9c3ea7f..00000000
--- a/src/emevo/environments/pymunk_envs/circle.py
+++ /dev/null
@@ -1,626 +0,0 @@
-from __future__ import annotations
-
-from functools import cached_property, partial
-from typing import Any, Callable, Literal, NamedTuple, TypeVar
-
-import numpy as np
-import pymunk
-from loguru import logger
-from numpy.random import PCG64, Generator
-from numpy.typing import NDArray
-from pymunk.vec2d import Vec2d
-
-from emevo.body import Body, Encount
-from emevo.env import Env, Visualizer
-from emevo.environments.pymunk_envs import pymunk_utils as utils
-from emevo.environments.utils.color import Color
-from emevo.environments.utils.food_repr import ReprLoc, ReprLocFn, ReprNum, ReprNumFn
-from emevo.environments.utils.locating import (
-    CircleCoordinate,
-    Coordinate,
-    InitLoc,
-    InitLocFn,
-    SquareCoordinate,
-)
-from emevo.spaces import BoxSpace, NamedTupleSpace
-
-FN = TypeVar("FN")
-
-
-
-class CFObs(NamedTuple):
-    """Observation of an agent."""
-
-    sensor: NDArray
-    collision: NDArray
-    velocity: NDArray
-    angle: float
-    angular_velocity: float
-    energy: float
-
-    def __array__(self) -> NDArray:
-        return np.concatenate(
-            (
-                self.sensor.reshape(-1),
-                self.collision,
-                self.velocity,
-                [self.angle, self.angular_velocity, self.energy],
-            )
-        )
-
-    @property
-    def n_collided_foods(self) -> float:
-        return self.collision[utils.CollisionType.FOOD.value]
-
-    @property
-    def n_collided_agents(self) -> float:
-        return self.collision[utils.CollisionType.AGENT.value]
-
-
-class _CFBodyInfo(NamedTuple):
-    position: Vec2d
-    velocity: Vec2d
-
-
-class CFBody(Body[Vec2d]):
-    """Body of an agent."""
-
-    _TWO_PI = np.pi * 2
-
-    def __init__(
-        self,
-        *,
-        body_with_sensors: utils.BodyWithSensors,
-        space: pymunk.Space,
-        generation: int,
-        birthtime: int,
-        min_acts: list[float],
-        max_acts: list[float],
-        loc: Vec2d,
-        max_abs_velocity: float,
-    ) -> None:
-        self._body, self._shape, self._sensors = body_with_sensors
-        self._body.position = loc
-        radius = self._shape.radius
-        self._p1 = Vec2d(0, radius).rotated(np.pi * 0.75)
-        self._p2 = Vec2d(0, radius).rotated(-np.pi * 0.75)
-        space.add(self._body, self._shape, *self._sensors)
-        n_sensors = len(self._sensors)
-        obs_space = NamedTupleSpace(
-            CFObs,
-            sensor=BoxSpace(low=0.0, high=1.0, shape=(n_sensors, 3)),
-            collision=BoxSpace(low=0.0, high=1.0, shape=(3,)),
-            velocity=BoxSpace(low=-max_abs_velocity, high=max_abs_velocity, shape=(2,)),
-            angle=BoxSpace(low=-2 * np.pi, high=2 * np.pi, shape=(1,)),
-            angular_velocity=BoxSpace(low=-np.pi / 10, high=np.pi / 10, shape=(1,)),
-            energy=BoxSpace(low=0.0, high=50.0, shape=(1,)),
-        )
-        super().__init__(
-            BoxSpace(
-                low=np.array(min_acts, dtype=np.float32),
-                high=np.array(max_acts, dtype=np.float32),
-            ),
-            obs_space,
-            generation,
-            birthtime,
-        )
-
-    def info(self) -> Any:
-        return _CFBodyInfo(position=self._body.position, velocity=self._body.velocity)
-
-    def _apply_action(self, action: NDArray) -> None:
-        f1, f2 = self.act_space.clip(action)
-        self._body.apply_impulse_at_local_point(Vec2d(0, f1), self._p1)
-        self._body.apply_impulse_at_local_point(Vec2d(0, f2), self._p2)
-
-    def _remove(self, space: pymunk.Space) -> None:
-        space.remove(self._body, self._shape, *self._sensors)
-
-    def location(self) -> pymunk.vec2d.Vec2d:
-        return self._body.position
-
-
-def _range(segment: tuple[float, float]) -> float:
-    return segment[1] - segment[0]
-
-
-def _default_energy_function(_body: CFBody) -> float:
-    return 0.0
-
-
-def _get_num_or_loc_fn(
-    arg: str | tuple | FN,
-    enum_type: Callable[..., Callable[..., FN]],
-    default_args: dict[str, tuple[Any, ...]],
-) -> FN:
-    if isinstance(arg, str):
-        return enum_type(arg)(*default_args[arg])
-    elif isinstance(arg, tuple) or isinstance(arg, list):
-        name, *args = arg
-        return enum_type(name)(*args)
-    else:
-        return arg
-
-
-class CircleForaging(Env[NDArray, Vec2d, CFObs]):
-    _AGENT_COLOR = Color(2, 204, 254)
-    _FOOD_COLOR = Color(254, 2, 162)
-    _WALL_RADIUS = 0.5
-
-    def __init__(
-        self,
-        n_initial_bodies: int = 6,
-        food_num_fn: ReprNumFn | str | tuple[str, ...] = "constant",
-        food_loc_fn: ReprLocFn | str | tuple[str, ...] = "gaussian",
-        body_loc_fn: InitLocFn | str | tuple[str, ...] = "uniform",
-        xlim: tuple[float, float] = (0.0, 200.0),
-        ylim: tuple[float, float] = (0.0, 200.0),
-        env_radius: float = 120.0,
-        env_shape: Literal["square", "circle"] = "square",
-        obstacles: list[tuple[float, float, float, float]] | None = None,
-        n_agent_sensors: int = 8,
-        sensor_length: float = 10.0,
-        sensor_range: tuple[float, float] = (-180.0, 180.0),
-        agent_radius: float = 12.0,
-        agent_mass: float = 1.0,
-        agent_friction: float = 0.1,
-        food_radius: float = 4.0,
-        food_mass: float = 0.25,
-        food_friction: float = 0.1,
-        food_initial_force: tuple[float, float] = (0.0, 0.0),
-        foodloc_interval: int = 1000,
-        wall_friction: float = 0.05,
-        max_abs_impulse: float = 0.2,
-        dt: float = 0.05,
-        damping: float = 1.0,
-        encount_threshold: int = 2,
-        n_physics_steps: int = 5,
-        max_place_attempts: int = 10,
-        body_elasticity: float = 0.4,
-        nofriction: bool = False,
-        energy_fn: Callable[[CFBody], float] = _default_energy_function,
-        seed: int | None = None,
-    ) -> None:
-        # Just copy some invariable configs
-        self._dt = dt
-        self._n_physics_steps = n_physics_steps
-        self._agent_radius = agent_radius
-        self._food_radius = food_radius
-        self._n_initial_bodies = n_initial_bodies
-        self._max_place_attempts = max_place_attempts
-        self._encount_threshold = min(encount_threshold, n_physics_steps)
-        self._n_sensors = n_agent_sensors
-        self._sensor_length = sensor_length
-        self._max_abs_impulse = max_abs_impulse
-        self._food_initial_force = food_initial_force
-        self._foodloc_interval = foodloc_interval
-        self._energy_fn = energy_fn
-        self._damping = damping
-        self._max_abs_velocity = 2 * np.ceil(  # Hack
-            np.sum([max_abs_impulse * 2 * (damping**i) for i in range(100)])
-        )
-
-        if env_shape == "square":
-            self._coordinate = SquareCoordinate(xlim, ylim, self._WALL_RADIUS)
-        elif env_shape == "circle":
-            self._coordinate = CircleCoordinate((env_radius, env_radius), env_radius)
-        else:
-            raise ValueError(f"Unsupported env_shape {env_shape}")
-
-        # nofriction overrides friction values
-        if nofriction:
-            agent_friction = 0.0
-            food_friction = 0.0
-            wall_friction = 0.0
-
-        # Save pymunk params in closures
-        self._make_pymunk_body = partial(
-            utils.circle_body_with_sensors,
-            radius=agent_radius,
-            n_sensors=n_agent_sensors,
-            sensor_length=sensor_length,
-            mass=agent_mass,
-            friction=agent_friction,
-            sensor_range=sensor_range,
-            elasticity=body_elasticity,
-        )
-        self._make_pymunk_food = partial(
-            utils.circle_body,
-            radius=food_radius,
-            collision_type=utils.CollisionType.FOOD,
-            mass=food_mass,
-            friction=food_friction,
-            body_type=pymunk.Body.STATIC,
-        )
-
-        # Customizable functions
-        self._food_num_fn = self._make_food_num_fn(food_num_fn)
-        self._xlim, self._ylim = self._coordinate.bbox()
-        self._x_range, self._y_range = _range(xlim), _range(ylim)
-        self._food_loc_fn = self._make_food_loc_fn(food_loc_fn)
-        self._body_loc_fn = self._make_body_loc_fn(body_loc_fn)
-        # Variables
-        self._sim_steps = 0
-        self._n_foods = 0
-        self._space = pymunk.Space()
-        self._space.damping = damping
-        # Setup physical objects
-        if isinstance(self._coordinate, SquareCoordinate):
-            utils.add_static_square(
-                self._space,
-                *xlim,
-                *ylim,
-                friction=wall_friction,
-                radius=self._WALL_RADIUS,
-                rounded_offset=np.floor(food_radius * 2 / (np.sqrt(2) - 1.0)),
-            )
-        elif isinstance(self._coordinate, CircleCoordinate):
-            utils.add_static_approximated_circle(
-                self._space,
-                self._coordinate.center,
-                self._coordinate.radius,
-                friction=wall_friction,
-            )
-
-        # Set obstacles
-        if obstacles is not None:
-            for obstacle in obstacles:
-                utils.add_static_line(
-                    self._space,
-                    obstacle[:2],
-                    obstacle[2:],
-                    friction=wall_friction,
-                    radius=self._WALL_RADIUS,
-                )
-        self._bodies = []
-        self._body_indices = {}
-        self._foods: dict[pymunk.Body, pymunk.Shape] = {}
-        self._encounted_bodies = set()
-        self._generator = Generator(PCG64(seed=seed))
-        # Shape filter
-        self._all_shape = pymunk.ShapeFilter()
-        # Place bodies and foods
-        self._initialize_bodies_and_foods()
-        # Setup all collision handlers
-        self._food_handler = utils.FoodHandler(self._body_indices)
-        self._mating_handler = utils.MatingHandler(self._body_indices)
-        self._static_handler = utils.StaticHandler(self._body_indices)
-
-        utils.add_pre_handler(
-            self._space,
-            utils.CollisionType.AGENT,
-            utils.CollisionType.FOOD,
-            self._food_handler,
-        )
-
-        utils.add_pre_handler(
-            self._space,
-            utils.CollisionType.AGENT,
-            utils.CollisionType.AGENT,
-            self._mating_handler,
-        )
-
-        utils.add_pre_handler(
-            self._space,
-            utils.CollisionType.AGENT,
-            utils.CollisionType.STATIC,
-            self._static_handler,
-        )
-
-    @staticmethod
-    def _make_food_num_fn(food_num_fn: str | tuple | ReprNumFn) -> ReprNumFn:
-        return _get_num_or_loc_fn(
-            food_num_fn,
-            ReprNum,  # type: ignore
-            {"constant": (10,), "linear": (10, 0.01), "logistic": (8, 1.2, 12)},
-        )
-
-    def _make_food_loc_fn(self, food_loc_fn: str | tuple | ReprLocFn) -> ReprLocFn:
-        return _get_num_or_loc_fn(
-            food_loc_fn,
-            ReprLoc,  # type: ignore
-            {
-                "gaussian": (
-                    (self._xlim[1] * 0.75, self._ylim[1] * 0.75),
-                    (self._x_range * 0.1, self._y_range * 0.1),
-                ),
-                "gaussian-mixture": (
-                    [0.5, 0.5],
-                    [
-                        (self._xlim[1] * 0.75, self._ylim[1] * 0.75),
-                        (self._xlim[1] * 0.25, self._ylim[1] * 0.75),
-                    ],
-                    [(self._x_range * 0.1, self._y_range * 0.1)] * 2,
-                ),
-                "switching": (
-                    self._foodloc_interval,
-                    (
-                        "gaussian",
-                        (self._xlim[1] * 0.75, self._ylim[1] * 0.75),
-                        (self._x_range * 0.1, self._y_range * 0.1),
-                    ),
-                    (
-                        "gaussian",
-                        (self._xlim[1] * 0.25, self._ylim[1] * 0.75),
-                        (self._x_range * 0.1, self._y_range * 0.1),
-                    ),
-                ),
-                "uniform": (self._coordinate,),
-            },
-        )
-
-    def _make_body_loc_fn(self, init_loc_fn: str | tuple | InitLocFn) -> InitLocFn:
-        return _get_num_or_loc_fn(
-            init_loc_fn,
-            InitLoc,  # type: ignore
-            {
-                "gaussian": (
-                    (self._xlim[1] * 0.25, self._ylim[1] * 0.25),
-                    (self._x_range * 0.3, self._y_range * 0.3),
-                ),
-                "uniform": (self._coordinate,),
-            },
-        )
-
-    def set_food_num_fn(self, food_num_fn: str | tuple | ReprNumFn) -> None:
-        self._food_num_fn = self._make_food_num_fn(food_num_fn)
-
-    def set_food_loc_fn(self, food_loc_fn: str | tuple | ReprLocFn) -> None:
-        self._food_loc_fn = self._make_food_loc_fn(food_loc_fn)
-
-    def set_body_loc_fn(self, body_loc_fn: str | tuple | InitLocFn) -> None:
-        self._body_loc_fn = self._make_body_loc_fn(body_loc_fn)
-
-    def set_energy_fn(self, energy_fn: Callable[[CFBody], float]) -> None:
-        self._energy_fn = energy_fn
-
-    def get_space(self) -> pymunk.Space:
-        return self._space
-
-    def get_coordinate(self) -> Coordinate:
-        return self._coordinate
-
-    def get_body_index(self, body: pymunk.Body) -> int | None:
-        return self._body_indices.get(body, None)
-
-    def bodies(self) -> list[CFBody]:
-        """Return the list of all bodies"""
-        return self._bodies
-
-    def step(self, actions: dict[CFBody, NDArray]) -> list[Encount]:
-        self._before_step()
-        # Add force
-        for body, action in actions.items():
-            body._apply_action(action)
-        # Step the simulation
-        for _ in range(self._n_physics_steps):
-            self._space.step(dt=self._dt)
-        # Remove foods
-        n_eaten_foods = len(self._food_handler.eaten_bodies)
-        if n_eaten_foods > 0:
-            logger.debug(f"{n_eaten_foods} foods are eaten")
-            for food_body in self._food_handler.eaten_bodies:
-                food_shape = self._foods.pop(food_body)
-                self._space.remove(food_body, food_shape)
-        # Generate new foods
-        locations = [body.position for body in self._foods.keys()]
-        n_new_foods = self._food_num_fn(len(locations))
-        if n_new_foods > 0:
-            n_created = self._place_n_foods(n_new_foods, locations)
-            if n_created > 0:
-                logger.debug(f"{n_created} foods are created")
-        # Increment the step
-        self._sim_steps += 1
-        return self._all_encounts()
-
-    def observe(self, body: CFBody) -> CFObs:
-        """
-        Observe the environment.
-        More specifically, an observation of each agent consists of:
-        - Sensor observation for agent/food/static object
-        - Collision to agent/food/static object
-        - Velocity of the body
-        """
-        sensor_data = self._accumulate_sensor_data(body)
-        collision_data = np.zeros(3, dtype=np.float32)
-        collision_data[0] = body.index in self._encounted_bodies
-        collision_data[1] = self._food_handler.n_ate_foods[body.index]
-        collision_data[2] = body.index in self._static_handler.collided_bodies
-        return CFObs(
-            sensor=sensor_data,
-            collision=collision_data,
-            velocity=body._body.velocity,
-            angle=body._body.angle % (2.0 * np.pi),
-            angular_velocity=body._body.angular_velocity,
-            energy=self._energy_fn(body),
-        )
-
-    def reset(self, seed: int | NDArray | None = None) -> None:
-        # Reset indices
-        self._sim_steps = 0
-        # Remove agents
-        for body in self._bodies:
-            body._remove(self._space)
-        self._bodies.clear()
-        # Remove foods
-        for body, shape in self._foods.items():
-            self._space.remove(body, shape)
-        self._foods.clear()
-        self._generator = Generator(PCG64(seed=seed))
-        self._initialize_bodies_and_foods()
-
-    def locate_body(self, location: Vec2d, generation: int) -> CFBody | None:
-        if self._can_place(location, self._agent_radius):
-            body = self._make_body(generation=generation, loc=location)
-            self._bodies.append(body)
-            return body
-        else:
-            logger.warning(f"Failed to place the body at {location}")
-            return None
-
-    def remove_body(self, body: CFBody) -> bool:
-        if body._body in self._body_indices:
-            body._remove(self._space)
-            self._bodies.remove(body)
-            del self._body_indices[body._body]
-            return True
-        else:
-            return False
-
-    def is_extinct(self) -> bool:
-        return len(self._bodies) == 0
-
-    def visualizer(
-        self,
-        mode: str,
-        figsize: tuple[float, float] | None = None,
-        mgl_backend: str = "pyglet",
-        **kwargs,
-    ) -> Visualizer:
-        mode = mode.lower()
-        xlim, ylim = self._coordinate.bbox()
-        if mode == "pygame":
-            from emevo.environments.pymunk_envs import pygame_vis
-
-            return pygame_vis.PygameVisualizer(
-                x_range=_range(xlim),
-                y_range=_range(ylim),
-                figsize=figsize,
-                **kwargs,
-            )
-        elif mode == "moderngl":
-            from emevo.environments.pymunk_envs import moderngl_vis
-
-            return moderngl_vis.MglVisualizer(
-                x_range=_range(xlim),
-                y_range=_range(ylim),
-                env=self,
-                figsize=figsize,
-                backend=mgl_backend,
-                **kwargs,
-            )
-        else:
-            raise ValueError(f"Invalid mode: {mode}")
-
-    def _accumulate_sensor_data(self, body: CFBody) -> NDArray:
-        sensor_data = np.zeros((3, self._n_sensors), dtype=np.float32)
-        for i, sensor in enumerate(body._sensors):
-            query_result = utils.sensor_query(self._space, body._body, sensor)
-            if query_result is not None:
-                categ, dist = query_result
-                assert categ in [
-                    utils.CollisionType.AGENT,
-                    utils.CollisionType.FOOD,
-                    utils.CollisionType.STATIC,
-                ]
-                sensor_data[categ.value][i] = 1.0 - dist
-        return sensor_data
-
-    def _all_encounts(self) -> list[Encount]:
-        all_encounts = []
-        for id_a, id_b in self._mating_handler.filter_pairs(self._encount_threshold):
-            self._encounted_bodies.add(id_a)
-            self._encounted_bodies.add(id_b)
-            body_a = self._find_body_by_id(id_a)
-            body_b = self._find_body_by_id(id_b)
-            all_encounts.append(Encount(body_a, body_b))
-        return all_encounts
-
-    def _before_step(self) -> None:
-        """Clear all collision handlers before step is called"""
-        self._food_handler.clear()
-        self._mating_handler.clear()
-        self._static_handler.clear()
-        self._encounted_bodies.clear()
-
-    def _can_place(self, point: Vec2d, radius: float) -> bool:
-        if not self._coordinate.contains_circle(point, radius):
-            return False
-        nearest = self._space.point_query_nearest(point, radius, self._all_shape)
-        return nearest is None
-
-    def _find_body_by_id(self, index: int) -> CFBody:
-        for body in self._bodies:
-            if body.index == index:
-                return body
-        raise ValueError(f"Invalid agent index: {index}")
-
-    def _initialize_bodies_and_foods(self) -> None:
-        assert len(self._bodies) == 0 and len(self._foods) == 0
-
-        for _ in range(self._n_initial_bodies):
-            point = self._try_placing_agent()
-            if point is None:
-                logger.warning("Failed to place a body")
-            else:
-                body = self._make_body(generation=0, loc=Vec2d(*point))
-                self._bodies.append(body)
-
-        self._place_n_foods(self._food_num_fn.initial)
-
-    @cached_property
-    def _min_max_abs_acts(self) -> tuple[list[float], list[float]]:
-        return [0, 0], [self._max_abs_impulse, self._max_abs_impulse]
-
-    def _make_body(self, generation: int, loc: Vec2d) -> CFBody:
-        body_with_sensors = self._make_pymunk_body()
-        body_with_sensors.shape.color = self._AGENT_COLOR
-        body_with_sensors.body.angle = self._generator.uniform(0.0, 2 * np.pi)
-        min_acts, max_acts = self._min_max_abs_acts
-        fgbody = CFBody(
-            body_with_sensors=body_with_sensors,
-            space=self._space,
-            generation=generation,
-            birthtime=self._sim_steps,
-            min_acts=min_acts,
-            max_acts=max_acts,
-            loc=loc,
-            max_abs_velocity=self._max_abs_velocity,
-        )
-        self._body_indices[body_with_sensors.body] = fgbody.index
-        return fgbody
-
-    def _make_food(self, loc: Vec2d) -> tuple[pymunk.Body, pymunk.Shape]:
-        body, shape = self._make_pymunk_food()
-        shape.color = self._FOOD_COLOR
-        if any(map(lambda value: value != 0.0, self._food_initial_force)):
-            mean, stddev = self._food_initial_force
-            force = self._generator.normal(loc=mean, scale=stddev, size=(2,))
-            body.apply_force_at_local_point(Vec2d(*force))
-        body.position = loc
-        self._space.add(body, shape)
-        return body, shape
-
-    def _place_n_foods(
-        self,
-        n_foods: int,
-        food_locations: list[pymunk.Vec2d] | None = None,
-    ) -> int:
-        if food_locations is None:
-            food_locations = []
-        success = 0
-        for _ in range(n_foods):
-            point = self._try_placing_food(food_locations)
-            if point is None:
-                logger.warning("Failed to place a food")
-            else:
-                loc = Vec2d(*point)
-                food_locations.append(loc)
-                food_body, food_shape = self._make_food(loc=loc)
-                self._foods[food_body] = food_shape
-                success += 1
-        return success
-
-    def _try_placing_agent(self) -> NDArray | None:
-        for _ in range(self._max_place_attempts):
-            sampled = self._body_loc_fn(self._generator)
-            if self._can_place(Vec2d(*sampled), self._agent_radius):
-                return sampled
-        return None
-
-    def _try_placing_food(self, locations: list[Vec2d]) -> NDArray | None:
-        for _ in range(self._max_place_attempts):
-            sampled = self._food_loc_fn(self._generator, locations)
-            if self._can_place(Vec2d(*sampled), self._food_radius):
-                return sampled
-        return None
diff --git a/src/emevo/environments/pymunk_envs/pygame_vis.py b/src/emevo/environments/pymunk_envs/pygame_vis.py
deleted file mode 100644
index 0ccba77d..00000000
--- a/src/emevo/environments/pymunk_envs/pygame_vis.py
+++ /dev/null
@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-import pygame
-import pymunk.pygame_util
-from numpy.typing import NDArray
-
-from emevo.environments.pymunk_envs.pymunk_env import PymunkEnv
-from emevo.visualizer import Visualizer
-
-
-class PygameVisualizer(Visualizer):
-    def __init__(
-        self,
-        x_range: float,
-        y_range: float,
-        figsize: tuple[float, float] | None = None,
-    ) -> None:
-        if figsize is None:
-            self._figsize = x_range * 3, y_range * 3
-        else:
-            self._figsize = figsize
-        pygame.display.init()
-        self._background = pygame.Rect(0, 0, x_range, y_range)
-        self._screen = pygame.display.set_mode(self._figsize)
-        self._pymunk_surface = pygame.Surface((x_range, y_range))
-        pymunk.pygame_util.positive_y_is_up = True
-        self._draw_options = pymunk.pygame_util.DrawOptions(self._pymunk_surface)
-
-    def close(self) -> None:
-        pygame.display.quit()
-        pygame.quit()
-
-    def get_image(self) -> NDArray:
-        return pygame.surfarray.pixels3d(self._screen).copy()
-
-    def render(self, env: PymunkEnv) -> None:
-        pygame.draw.rect(self._pymunk_surface, (255, 255, 255), self._background)
-        env.get_space().debug_draw(self._draw_options)
-
-    def show(self) -> None:
-        transform = pygame.transform.smoothscale(self._pymunk_surface, self._figsize)
-        self._screen.blit(transform, (0, 0))
-        pygame.display.flip()
diff --git a/src/emevo/environments/pymunk_envs/pymunk_env.py b/src/emevo/environments/pymunk_envs/pymunk_env.py
deleted file mode 100644
index 423f173a..00000000
--- a/src/emevo/environments/pymunk_envs/pymunk_env.py
+++ /dev/null
@@ -1,19 +0,0 @@
-"""A common interface for pymunk envs."""
-from __future__ import annotations
-
-from typing import Protocol
-
-import pymunk
-
-from emevo.environments.utils.locating import Coordinate
-
-
-class PymunkEnv(Protocol):
-    def get_space(self) -> pymunk.Space:
-        ...
-
-    def get_coordinate(self) -> Coordinate:
-        ...
-
-    def get_body_index(self, body: pymunk.Body) -> int | None:
-        ...
diff --git a/src/emevo/environments/pymunk_envs/pymunk_utils.py b/src/emevo/environments/pymunk_envs/pymunk_utils.py
deleted file mode 100644
index 802e9560..00000000
--- a/src/emevo/environments/pymunk_envs/pymunk_utils.py
+++ /dev/null
@@ -1,315 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-import enum
-from collections import defaultdict
-from typing import Any, Callable, Iterable, NamedTuple
-
-import numpy as np
-import pymunk
-from pymunk.body import Vec2d
-from pymunk.shapes import Circle
-
-SENSOR_OFFSET: float = 1e-6
-
-
-class CollisionType(enum.IntEnum):
-    AGENT = 0
-    FOOD = 1
-    STATIC = 2
-    POISON = 3
-    SENSOR = 4
-
-    def categ_filter(self) -> pymunk.ShapeFilter:
-        return pymunk.ShapeFilter(categories=1 << self.value)
-
-
-def make_filter(*collision_types: CollisionType) -> pymunk.ShapeFilter:
-    mask = 0
-    for collision_type in collision_types:
-        mask |= 1 << collision_type.value
-    return pymunk.ShapeFilter(mask)
-
-
-def _select(
-    shapes: tuple[pymunk.Shape, pymunk.Shape],
-    target_type: CollisionType,
-) -> pymunk.Shape:
-    for shape in shapes:
-        if shape.collision_type == target_type.value:
-            return shape
-    raise RuntimeError(f"Collision type {target_type} is not found in {shapes}")
-
-
-def add_pre_handler(
-    space: pymunk.Space,
-    type_a: CollisionType,
-    type_b: CollisionType,
-    callback: Callable[[pymunk.arbiter.Arbiter, pymunk.Space, Any], bool],
-) -> None:
-    """Add pre_solve handler to the space."""
-    collision_handler = space.add_collision_handler(type_a.value, type_b.value)
-    collision_handler.pre_solve = callback
-
-
-@dataclasses.dataclass
-class FoodHandler:
-    """
-    Handle collisions between agent and food.
-    """
-
-    body_indices: dict[pymunk.Body, int]
-    eaten_bodies: set[pymunk.Body] = dataclasses.field(default_factory=set)
-    n_ate_foods: dict[int, int] = dataclasses.field(
-        default_factory=lambda: defaultdict(lambda: 0)
-    )
-
-    def __call__(
-        self,
-        arbiter: pymunk.arbiter.Arbiter,
-        _space: pymunk.Space,
-        _info: Any,
-    ) -> bool:
-        """
-        Implementation of collision handling callback passed to pymunk.
-        Store eaten foods and the number of food an agent ate.
-        Return False for already eaten foods.
-        """
-        a, b = arbiter.shapes
-        if a.collision_type == CollisionType.FOOD.value:
-            food, agent = a.body, b.body
-        else:
-            food, agent = b.body, a.body
-        if food in self.eaten_bodies:
-            return False
-        else:
-            self.eaten_bodies.add(food)
-            index = self.body_indices[agent]
-            self.n_ate_foods[index] += 1
-            return True
-
-    def clear(self) -> None:
-        self.eaten_bodies.clear()
-        for index in self.n_ate_foods.keys():
-            self.n_ate_foods[index] = 0
-
-
-@dataclasses.dataclass
-class MatingHandler:
-    """
-    Handle collisions between agents.
-    """
-
-    body_indices: dict[pymunk.Body, int]
-    collided_steps: dict[tuple[int, int], int] = dataclasses.field(
-        default_factory=lambda: defaultdict(lambda: 0)
-    )
-
-    def __call__(
-        self,
-        arbiter: pymunk.arbiter.Arbiter,
-        _space: pymunk.Space,
-        _info: Any,
-    ) -> bool:
-        """
-        Store collided bodies and the number of collisions per each pair.
-        Always return True.
-        """
-        a, b = map(lambda shape: self.body_indices[shape.body], arbiter.shapes)
-        key = min(a, b), max(a, b)
-        self.collided_steps[key] += 1
-        return True
-
-    def clear(self) -> None:
-        for key in self.collided_steps.keys():
-            self.collided_steps[key] = 0
-
-    def filter_pairs(self, threshold: int) -> Iterable[tuple[int, int]]:
-        """Iterate pairs that collided more than threshold"""
-        for pair, n_collided in self.collided_steps.items():
-            if threshold <= n_collided:
-                yield pair
-
-
-@dataclasses.dataclass
-class StaticHandler:
-    """Handle collisions between agents and static objects."""
-
-    body_indices: dict[pymunk.Body, int]
-    collided_bodies: set[int] = dataclasses.field(default_factory=set)
-
-    def __call__(
-        self,
-        arbiter: pymunk.arbiter.Arbiter,
-        _space: pymunk.Space,
-        _info: Any,
-    ) -> bool:
-        """Store collided bodies. Always return True."""
-        shape = _select(arbiter.shapes, CollisionType.AGENT)
-        self.collided_bodies.add(self.body_indices[shape.body])
-        return True
-
-    def clear(self) -> None:
-        self.collided_bodies.clear()
-
-
-_DEFAULT_MASK = pymunk.ShapeFilter.ALL_MASKS() ^ (1 << CollisionType.SENSOR.value)
-
-
-def sensor_query(
-    space: pymunk.Space,
-    body: pymunk.Body,
-    segment: pymunk.Segment,
-    mask: int = _DEFAULT_MASK,
-) -> tuple[CollisionType, float] | None:
-    """Get the nearest object aligned with given segment"""
-    start = body.position + segment.a
-    end = body.position + segment.b
-    shape_filter = pymunk.ShapeFilter(mask=mask)
-    query_result = space.segment_query_first(start, end, 0.0, shape_filter)
-    if query_result is None or query_result.shape is None:
-        return None
-    else:
-        collision_type = CollisionType(query_result.shape.collision_type)
-        return collision_type, query_result.alpha
-
-
-class BodyWithSensors(NamedTuple):
-    """Pymunk body with touch sensors."""
-
-    body: pymunk.Body
-    shape: pymunk.Shape
-    sensors: list[pymunk.Segment]
-
-
-def circle_body(
-    radius: float,
-    collision_type: CollisionType,
-    mass: float = 1.0,
-    friction: float = 0.6,
-    elasticity: float = 0.0,
-    body_type: int = pymunk.Body.DYNAMIC,
-) -> tuple[pymunk.Body, Circle]:
-    body = pymunk.Body(body_type=body_type)
-    circle = pymunk.Circle(body, radius)
-    circle.mass = mass
-    circle.friction = friction
-    circle.collision_type = collision_type
-    circle.filter = collision_type.categ_filter()
-    circle.elasticity = elasticity
-    return body, circle
-
-
-def circle_body_with_sensors(
-    radius: float,
-    n_sensors: int,
-    sensor_length: float,
-    mass: float = 1.0,
-    friction: float = 0.6,
-    elasticity: float = 0.0,
-    sensor_range: tuple[float, float] = (-180, 180),
-) -> BodyWithSensors:
-    body, circle = circle_body(
-        radius=radius,
-        collision_type=CollisionType.AGENT,
-        mass=mass,
-        friction=friction,
-        elasticity=elasticity,
-    )
-    sensors = []
-    sensor_rad = np.deg2rad(sensor_range)
-    sensor_in = Vec2d(0.0, radius + SENSOR_OFFSET)
-    sensor_out = Vec2d(0.0, radius + sensor_length)
-    for theta in np.linspace(sensor_rad[0], sensor_rad[1], n_sensors + 1)[:-1]:
-        seg = pymunk.Segment(
-            body,
-            sensor_in.rotated(theta),
-            sensor_out.rotated(theta),
-            0.5,
-        )
-        seg.sensor = True
-        seg.collision_type = CollisionType.SENSOR
-        seg.filter = pymunk.ShapeFilter(categories=CollisionType.SENSOR.value, mask=0)
-        sensors.append(seg)
-    return BodyWithSensors(body=body, shape=circle, sensors=sensors)
-
-
-def add_static_line(
-    space: pymunk.Space,
-    start: tuple[float, float],
-    end: tuple[float, float],
-    elasticity: float = 0.95,
-    friction: float = 0.5,
-    radius: float = 1.0,
-) -> pymunk.Segment:
-    line = pymunk.Segment(space.static_body, start, end, radius)
-    line.elasticity = elasticity
-    line.friction = friction
-    line.collision_type = CollisionType.STATIC
-    line.filter = CollisionType.STATIC.categ_filter()
-    space.add(line)
-    return line
-
-
-def add_static_square(
-    space: pymunk.Space,
-    xmin: float,
-    xmax: float,
-    ymin: float,
-    ymax: float,
-    rounded_offset: float | None = None,
-    **kwargs,
-) -> list[pymunk.Segment]:
-    p1 = xmin, ymin
-    p2 = xmin, ymax
-    p3 = xmax, ymax
-    p4 = xmax, ymin
-    lines = []
-    if rounded_offset is not None:
-        for start, end in [(p1, p2), (p2, p3), (p3, p4), (p4, p1)]:
-            s2end = Vec2d(*end) - Vec2d(*start)
-            offset = s2end.normalized() * rounded_offset
-            stop = end - offset
-            line = add_static_line(
-                space,
-                start + offset,
-                stop,
-                **kwargs,
-            )
-            lines.append(line)
-            stop2end = end - stop
-            center = stop + stop2end.rotated(-np.pi / 2)
-            for i in range(4):
-                line = add_static_line(
-                    space,
-                    center + stop2end.rotated(np.pi / 8 * i),
-                    center + stop2end.rotated(np.pi / 8 * (i + 1)),
-                    **kwargs,
-                )
-                lines.append(line)
-    else:
-        for start, end in [(p1, p2), (p2, p3), (p3, p4), (p4, p1)]:
-            line = add_static_line(space, start, end, **kwargs)
-            lines.append(line)
-    return lines
-
-
-def add_static_approximated_circle(
-    space: pymunk.Space,
-    center: tuple[float, float],
-    radius: float,
-    n_lines: int = 32,
-    **kwargs,
-) -> list[pymunk.Segment]:
-    unit = np.pi * 2 / n_lines
-    lines = []
-    t0 = Vec2d(radius, 0.0)
-    for i in range(n_lines):
-        line = add_static_line(
-            space,
-            center + t0.rotated(unit * i),
-            center + t0.rotated(unit * (i + 1)),
-            **kwargs,
-        )
-        lines.append(line)
-    return lines

From 634e1ac0001ec7c4ac43516acd7e54de101a3e79 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 3 Nov 2023 15:17:15 +0900
Subject: [PATCH 062/337] RL module

---
 pyproject.toml              |   6 +-
 src/emevo/rl/ppo_softmax.py | 266 ++++++++++++++++++++++++++++++++++++
 2 files changed, 268 insertions(+), 4 deletions(-)
 create mode 100644 src/emevo/rl/ppo_softmax.py

diff --git a/pyproject.toml b/pyproject.toml
index 0f391ae5..c9582775 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -20,11 +20,9 @@ classifiers = [
 requires-python = ">= 3.9"
 dependencies = [
     "chex >= 0.1.82",
-    "loguru >= 0.6",
+    "equinox >= 0.11",
     "jax >= 0.4",
-    "pymunk >= 6.0",
-    "scipy >= 1.0",
-    "typing_extensions >= 4.0"
+    "optax >= 0.1",
 ]
 dynamic = ["version"]
 
diff --git a/src/emevo/rl/ppo_softmax.py b/src/emevo/rl/ppo_softmax.py
new file mode 100644
index 00000000..74c33d72
--- /dev/null
+++ b/src/emevo/rl/ppo_softmax.py
@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+from typing import NamedTuple
+
+import chex
+import jax
+import jax.numpy as jnp
+import optax
+from jax.nn.initializers import orthogonal
+
+
+class PPONetOutput(NamedTuple):
+    policy_logits: jax.Array
+    value: jax.Array
+
+
+class SoftmaxPPONet(eqx.Module):
+    torso: list
+    value_head: eqx.nn.Linear
+    policy_head: eqx.nn.Linear
+
+    def __init__(self, key: jax.Array) -> None:
+        key1, key2, key3, key4, key5 = jax.random.split(key, 5)
+        # Common layers
+        self.torso = [
+            eqx.nn.Conv2d(3, 1, kernel_size=3, key=key1),
+            jax.nn.relu,
+            jnp.ravel,
+            eqx.nn.Linear(64, 64, key=key2),
+            jax.nn.relu,
+        ]
+        self.value_head = eqx.nn.Linear(64, 1, key=key3)
+        policy_head = eqx.nn.Linear(64, 4, key=key4)
+        # Use small value for policy initialization
+        self.policy_head = eqx.tree_at(
+            lambda linear: linear.weight,
+            policy_head,
+            orthogonal(scale=0.01)(key5, policy_head.weight.shape),
+        )
+
+    def __call__(self, x: jax.Array) -> PPONetOutput:
+        for layer in self.torso:
+            x = layer(x)
+        value = self.value_head(x)
+        policy_logits = self.policy_head(x)
+        return PPONetOutput(policy_logits=policy_logits, value=value)
+
+    def value(self, x: jax.Array) -> jax.Array:
+        for layer in self.torso:
+            x = layer(x)
+        return self.value_head(x)
+
+@chex.dataclass
+class Rollout:
+    """Rollout buffer that stores the entire history of one rollout"""
+
+    observations: jax.Array
+    actions: jax.Array
+    action_masks: jax.Array
+    rewards: jax.Array
+    terminations: jax.Array
+    values: jax.Array
+    policy_logits: jax.Array
+
+
+def mask_logits(policy_logits: jax.Array, action_mask: jax.Array) -> jax.Array:
+    return jax.lax.select(
+        action_mask,
+        policy_logits,
+        jnp.ones_like(policy_logits) * -jnp.inf,
+    )
+
+
+vmapped_obs2i = jax.vmap(obs_to_image)
+
+
+@eqx.filter_jit
+def exec_rollout(
+    initial_state: State,
+    initial_obs: Observation,
+    env: jumanji.Environment,
+    network: SoftmaxPPONet,
+    prng_key: jax.Array,
+    n_rollout_steps: int,
+) -> tuple[State, Rollout, Observation, jax.Array]:
+    def step_rollout(
+        carried: tuple[State, Observation],
+        key: jax.Array,
+    ) -> tuple[tuple[State, jax.Array], Rollout]:
+        state_t, obs_t = carried
+        obs_image = vmapped_obs2i(obs_t)
+        net_out = jax.vmap(network)(obs_image)
+        masked_logits = mask_logits(net_out.policy_logits, obs_t.action_mask)
+        actions = jax.random.categorical(key, masked_logits, axis=-1)
+        state_t1, timestep = jax.vmap(env.step)(state_t, actions)
+        rollout = Rollout(
+            observations=obs_image,
+            actions=actions,
+            action_masks=obs_t.action_mask,
+            rewards=timestep.reward,
+            terminations=1.0 - timestep.discount,
+            values=net_out.value,
+            policy_logits=masked_logits,
+        )
+        return (state_t1, timestep.observation), rollout
+
+    (state, obs), rollout = jax.lax.scan(
+        step_rollout,
+        (initial_state, initial_obs),
+        jax.random.split(prng_key, n_rollout_steps),
+    )
+    next_value = jax.vmap(network.value)(vmapped_obs2i(obs))
+    return state, rollout, obs, next_value
+
+@chex.dataclass(frozen=True, mappable_dataclass=False)
+class Batch:
+    """Batch for PPO, indexable to get a minibatch."""
+
+    observations: jax.Array
+    action_masks: jax.Array
+    onehot_actions: jax.Array
+    rewards: jax.Array
+    advantages: jax.Array
+    value_targets: jax.Array
+    log_action_probs: jax.Array
+
+    def __getitem__(self, idx: jax.Array):
+        return self.__class__(  # type: ignore
+            observations=self.observations[idx],
+            action_masks=self.action_masks[idx],
+            onehot_actions=self.onehot_actions[idx],
+            rewards=self.rewards[idx],
+            advantages=self.advantages[idx],
+            value_targets=self.value_targets[idx],
+            log_action_probs=self.log_action_probs[idx],
+        )
+
+
+def compute_gae(
+    r_t: jax.Array,
+    discount_t: jax.Array,
+    values: jax.Array,
+    lambda_: float = 0.95,
+) -> jax.Array:
+    """Efficiently compute generalized advantage estimator (GAE)"""
+
+    gamma_lambda_t = discount_t * lambda_
+    delta_t = r_t + discount_t * values[1:] - values[:-1]
+    n = delta_t.shape[0]
+
+    def update(i: int, advantage_t: jax.Array) -> jax.Array:
+        t = n - i - 1
+        adv_t = delta_t[t] + gamma_lambda_t[t] * advantage_t[t + 1]
+        return advantage_t.at[t].set(adv_t)
+
+    advantage_t = jax.lax.fori_loop(0, n, update, jnp.zeros_like(values))
+    return advantage_t[:-1]
+
+
+@eqx.filter_jit
+def make_batch(
+    rollout: Rollout,
+    next_value: jax.Array,
+    gamma: float,
+    gae_lambda: float,
+) -> Batch:
+    all_values = jnp.concatenate(
+        [jnp.squeeze(rollout.values), next_value.reshape(1, -1)]
+    )
+    advantages = compute_gae(
+        rollout.rewards,
+        # Set γ = 0 when the episode terminates
+        (1.0 - rollout.terminations) * gamma,
+        all_values,
+        gae_lambda,
+    )
+    value_targets = advantages + all_values[:-1]
+    onehot_actions = jax.nn.one_hot(rollout.actions, 4)
+    _, _, *obs_shape = rollout.observations.shape
+    log_action_probs = jnp.sum(
+        jax.nn.log_softmax(rollout.policy_logits) * onehot_actions,
+        axis=-1,
+    )
+    return Batch(
+        observations=rollout.observations.reshape(-1, *obs_shape),
+        action_masks=rollout.action_masks.reshape(-1, 4),
+        onehot_actions=onehot_actions.reshape(-1, 4),
+        rewards=rollout.rewards.ravel(),
+        advantages=advantages.ravel(),
+        value_targets=value_targets.ravel(),
+        log_action_probs=log_action_probs.ravel(),
+    )
+
+
+def loss_function(
+    network: SoftmaxPPONet,
+    batch: Batch,
+    ppo_clip_eps: float,
+) -> jax.Array:
+    net_out = jax.vmap(network)(batch.observations)
+    # Policy loss
+    log_pi = jax.nn.log_softmax(
+        jax.lax.select(
+            batch.action_masks,
+            net_out.policy_logits,
+            jnp.ones_like(net_out.policy_logits * -jnp.inf),
+        )
+    )
+    log_action_probs = jnp.sum(log_pi * batch.onehot_actions, axis=-1)
+    policy_ratio = jnp.exp(log_action_probs - batch.log_action_probs)
+    clipped_ratio = jnp.clip(policy_ratio, 1.0 - ppo_clip_eps, 1.0 + ppo_clip_eps)
+    clipped_objective = jnp.fmin(
+        policy_ratio * batch.advantages,
+        clipped_ratio * batch.advantages,
+    )
+    policy_loss = -jnp.mean(clipped_objective)
+    # Value loss
+    value_loss = jnp.mean(0.5 * (net_out.value - batch.value_targets) ** 2)
+    # Entropy regularization
+    entropy = jnp.mean(-jnp.exp(log_pi) * log_pi)
+    return policy_loss + value_loss - 0.01 * entropy
+
+
+vmapped_permutation = jax.vmap(jax.random.permutation, in_axes=(0, None), out_axes=0)
+
+
+@eqx.filter_jit
+def update_network(
+    batch: Batch,
+    network: SoftmaxPPONet,
+    optax_update: optax.TransformUpdateFn,
+    opt_state: optax.OptState,
+    prng_key: jax.Array,
+    minibatch_size: int,
+    n_epochs: int,
+    ppo_clip_eps: float,
+) -> tuple[optax.OptState, SoftmaxPPONet]:
+    # Prepare update function
+    dynamic_net, static_net = eqx.partition(network, eqx.is_array)
+
+    def update_once(
+        carried: tuple[optax.OptState, SoftmaxPPONet],
+        batch: Batch,
+    ) -> tuple[tuple[optax.OptState, SoftmaxPPONet], None]:
+        opt_state, dynamic_net = carried
+        network = eqx.combine(dynamic_net, static_net)
+        grad = eqx.filter_grad(loss_function)(network, batch, ppo_clip_eps)
+        updates, new_opt_state = optax_update(grad, opt_state)
+        dynamic_net = optax.apply_updates(dynamic_net, updates)
+        return (new_opt_state, dynamic_net), None
+
+    # Prepare minibatches
+    batch_size = batch.observations.shape[0]
+    permutations = vmapped_permutation(jax.random.split(prng_key, n_epochs), batch_size)
+    minibatches = jax.tree_map(
+        # Here, x's shape is [batch_size, ...]
+        lambda x: x[permutations].reshape(-1, minibatch_size, *x.shape[1:]),
+        batch,
+    )
+    # Update network n_epochs x n_minibatches times
+    (opt_state, updated_dynet), _ = jax.lax.scan(
+        update_once,
+        (opt_state, dynamic_net),
+        minibatches,
+    )
+    return opt_state, eqx.combine(updated_dynet, static_net)

From cd5e7a93de7bcd61cb800ddf7f355f810aebd942 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 3 Nov 2023 17:07:01 +0900
Subject: [PATCH 063/337] Start implementing PPO

---
 .../rl/{ppo_softmax.py => ppo_gaussian.py}    | 98 +++++++++++--------
 1 file changed, 56 insertions(+), 42 deletions(-)
 rename src/emevo/rl/{ppo_softmax.py => ppo_gaussian.py} (78%)

diff --git a/src/emevo/rl/ppo_softmax.py b/src/emevo/rl/ppo_gaussian.py
similarity index 78%
rename from src/emevo/rl/ppo_softmax.py
rename to src/emevo/rl/ppo_gaussian.py
index 74c33d72..cea71867 100644
--- a/src/emevo/rl/ppo_softmax.py
+++ b/src/emevo/rl/ppo_gaussian.py
@@ -15,7 +15,7 @@ class PPONetOutput(NamedTuple):
 
 
 class SoftmaxPPONet(eqx.Module):
-    torso: list
+    torso: list[eqx.Module]
     value_head: eqx.nn.Linear
     policy_head: eqx.nn.Linear
 
@@ -71,47 +71,6 @@ def mask_logits(policy_logits: jax.Array, action_mask: jax.Array) -> jax.Array:
     )
 
 
-vmapped_obs2i = jax.vmap(obs_to_image)
-
-
-@eqx.filter_jit
-def exec_rollout(
-    initial_state: State,
-    initial_obs: Observation,
-    env: jumanji.Environment,
-    network: SoftmaxPPONet,
-    prng_key: jax.Array,
-    n_rollout_steps: int,
-) -> tuple[State, Rollout, Observation, jax.Array]:
-    def step_rollout(
-        carried: tuple[State, Observation],
-        key: jax.Array,
-    ) -> tuple[tuple[State, jax.Array], Rollout]:
-        state_t, obs_t = carried
-        obs_image = vmapped_obs2i(obs_t)
-        net_out = jax.vmap(network)(obs_image)
-        masked_logits = mask_logits(net_out.policy_logits, obs_t.action_mask)
-        actions = jax.random.categorical(key, masked_logits, axis=-1)
-        state_t1, timestep = jax.vmap(env.step)(state_t, actions)
-        rollout = Rollout(
-            observations=obs_image,
-            actions=actions,
-            action_masks=obs_t.action_mask,
-            rewards=timestep.reward,
-            terminations=1.0 - timestep.discount,
-            values=net_out.value,
-            policy_logits=masked_logits,
-        )
-        return (state_t1, timestep.observation), rollout
-
-    (state, obs), rollout = jax.lax.scan(
-        step_rollout,
-        (initial_state, initial_obs),
-        jax.random.split(prng_key, n_rollout_steps),
-    )
-    next_value = jax.vmap(network.value)(vmapped_obs2i(obs))
-    return state, rollout, obs, next_value
-
 @chex.dataclass(frozen=True, mappable_dataclass=False)
 class Batch:
     """Batch for PPO, indexable to get a minibatch."""
@@ -264,3 +223,58 @@ def update_once(
         minibatches,
     )
     return opt_state, eqx.combine(updated_dynet, static_net)
+
+
+def run_training(
+    key: jax.Array,
+    adam_lr: float = 3e-4,
+    adam_eps: float = 1e-7,
+    gamma: float = 0.99,
+    gae_lambda: float = 0.95,
+    n_optim_epochs: int = 10,
+    minibatch_size: int = 1024,
+    n_agents: int = 16,
+    n_rollout_steps: int = 512,
+    n_total_steps: int = 16 * 512 * 100,
+    ppo_clip_eps: float = 0.2,
+    **env_kwargs,
+) -> SoftmaxPPONet:
+    key, net_key, reset_key = jax.random.split(key, 3)
+    pponet = SoftmaxPPONet(net_key)
+    env = AutoResetWrapper(jumanji.make("Maze-v0", **env_kwargs))
+    adam_init, adam_update = optax.adam(adam_lr, eps=adam_eps)
+    opt_state = adam_init(eqx.filter(pponet, eqx.is_array))
+    env_state, timestep = jax.vmap(env.reset)(jax.random.split(reset_key, 16))
+    obs = timestep.observation
+
+    n_loop = n_total_steps // (n_agents * n_rollout_steps)
+    return_reporting_interval = 1 if n_loop < 10 else n_loop // 10
+    n_episodes, reward_sum = 0.0, 0.0
+    for i in range(n_loop):
+        key, rollout_key, update_key = jax.random.split(key, 3)
+        env_state, rollout, obs, next_value = exec_rollout(
+            env_state,
+            obs,
+            env,
+            pponet,
+            rollout_key,
+            n_rollout_steps,
+        )
+        batch = make_batch(rollout, next_value, gamma, gae_lambda)
+        opt_state, pponet = update_network(
+            batch,
+            pponet,
+            adam_update,
+            opt_state,
+            update_key,
+            minibatch_size,
+            n_optim_epochs,
+            ppo_clip_eps,
+        )
+        n_episodes += jnp.sum(rollout.terminations).item()
+        reward_sum += jnp.sum(rollout.rewards).item()
+        if i > 0 and (i % return_reporting_interval == 0):
+            print(f"Mean episodic return: {reward_sum / n_episodes}")
+            n_episodes = 0.0
+            reward_sum = 0.0
+    return pponet

From 0747a0df428407b93b1ab601723cb2c8b974c97d Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 7 Nov 2023 18:06:41 +0900
Subject: [PATCH 064/337] Test PPO

---
 pyproject.toml               |   1 +
 src/emevo/rl/ppo_gaussian.py | 280 -----------------------------------
 src/emevo/rl/ppo_normal.py   | 239 ++++++++++++++++++++++++++++++
 tests/test_ppo.py            |  85 +++++++++++
 4 files changed, 325 insertions(+), 280 deletions(-)
 delete mode 100644 src/emevo/rl/ppo_gaussian.py
 create mode 100644 src/emevo/rl/ppo_normal.py
 create mode 100644 tests/test_ppo.py

diff --git a/pyproject.toml b/pyproject.toml
index c9582775..8d9c043c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -20,6 +20,7 @@ classifiers = [
 requires-python = ">= 3.9"
 dependencies = [
     "chex >= 0.1.82",
+    "distrax >= 0.1",
     "equinox >= 0.11",
     "jax >= 0.4",
     "optax >= 0.1",
diff --git a/src/emevo/rl/ppo_gaussian.py b/src/emevo/rl/ppo_gaussian.py
deleted file mode 100644
index cea71867..00000000
--- a/src/emevo/rl/ppo_gaussian.py
+++ /dev/null
@@ -1,280 +0,0 @@
-from __future__ import annotations
-
-from typing import NamedTuple
-
-import chex
-import jax
-import jax.numpy as jnp
-import optax
-from jax.nn.initializers import orthogonal
-
-
-class PPONetOutput(NamedTuple):
-    policy_logits: jax.Array
-    value: jax.Array
-
-
-class SoftmaxPPONet(eqx.Module):
-    torso: list[eqx.Module]
-    value_head: eqx.nn.Linear
-    policy_head: eqx.nn.Linear
-
-    def __init__(self, key: jax.Array) -> None:
-        key1, key2, key3, key4, key5 = jax.random.split(key, 5)
-        # Common layers
-        self.torso = [
-            eqx.nn.Conv2d(3, 1, kernel_size=3, key=key1),
-            jax.nn.relu,
-            jnp.ravel,
-            eqx.nn.Linear(64, 64, key=key2),
-            jax.nn.relu,
-        ]
-        self.value_head = eqx.nn.Linear(64, 1, key=key3)
-        policy_head = eqx.nn.Linear(64, 4, key=key4)
-        # Use small value for policy initialization
-        self.policy_head = eqx.tree_at(
-            lambda linear: linear.weight,
-            policy_head,
-            orthogonal(scale=0.01)(key5, policy_head.weight.shape),
-        )
-
-    def __call__(self, x: jax.Array) -> PPONetOutput:
-        for layer in self.torso:
-            x = layer(x)
-        value = self.value_head(x)
-        policy_logits = self.policy_head(x)
-        return PPONetOutput(policy_logits=policy_logits, value=value)
-
-    def value(self, x: jax.Array) -> jax.Array:
-        for layer in self.torso:
-            x = layer(x)
-        return self.value_head(x)
-
-@chex.dataclass
-class Rollout:
-    """Rollout buffer that stores the entire history of one rollout"""
-
-    observations: jax.Array
-    actions: jax.Array
-    action_masks: jax.Array
-    rewards: jax.Array
-    terminations: jax.Array
-    values: jax.Array
-    policy_logits: jax.Array
-
-
-def mask_logits(policy_logits: jax.Array, action_mask: jax.Array) -> jax.Array:
-    return jax.lax.select(
-        action_mask,
-        policy_logits,
-        jnp.ones_like(policy_logits) * -jnp.inf,
-    )
-
-
-@chex.dataclass(frozen=True, mappable_dataclass=False)
-class Batch:
-    """Batch for PPO, indexable to get a minibatch."""
-
-    observations: jax.Array
-    action_masks: jax.Array
-    onehot_actions: jax.Array
-    rewards: jax.Array
-    advantages: jax.Array
-    value_targets: jax.Array
-    log_action_probs: jax.Array
-
-    def __getitem__(self, idx: jax.Array):
-        return self.__class__(  # type: ignore
-            observations=self.observations[idx],
-            action_masks=self.action_masks[idx],
-            onehot_actions=self.onehot_actions[idx],
-            rewards=self.rewards[idx],
-            advantages=self.advantages[idx],
-            value_targets=self.value_targets[idx],
-            log_action_probs=self.log_action_probs[idx],
-        )
-
-
-def compute_gae(
-    r_t: jax.Array,
-    discount_t: jax.Array,
-    values: jax.Array,
-    lambda_: float = 0.95,
-) -> jax.Array:
-    """Efficiently compute generalized advantage estimator (GAE)"""
-
-    gamma_lambda_t = discount_t * lambda_
-    delta_t = r_t + discount_t * values[1:] - values[:-1]
-    n = delta_t.shape[0]
-
-    def update(i: int, advantage_t: jax.Array) -> jax.Array:
-        t = n - i - 1
-        adv_t = delta_t[t] + gamma_lambda_t[t] * advantage_t[t + 1]
-        return advantage_t.at[t].set(adv_t)
-
-    advantage_t = jax.lax.fori_loop(0, n, update, jnp.zeros_like(values))
-    return advantage_t[:-1]
-
-
-@eqx.filter_jit
-def make_batch(
-    rollout: Rollout,
-    next_value: jax.Array,
-    gamma: float,
-    gae_lambda: float,
-) -> Batch:
-    all_values = jnp.concatenate(
-        [jnp.squeeze(rollout.values), next_value.reshape(1, -1)]
-    )
-    advantages = compute_gae(
-        rollout.rewards,
-        # Set γ = 0 when the episode terminates
-        (1.0 - rollout.terminations) * gamma,
-        all_values,
-        gae_lambda,
-    )
-    value_targets = advantages + all_values[:-1]
-    onehot_actions = jax.nn.one_hot(rollout.actions, 4)
-    _, _, *obs_shape = rollout.observations.shape
-    log_action_probs = jnp.sum(
-        jax.nn.log_softmax(rollout.policy_logits) * onehot_actions,
-        axis=-1,
-    )
-    return Batch(
-        observations=rollout.observations.reshape(-1, *obs_shape),
-        action_masks=rollout.action_masks.reshape(-1, 4),
-        onehot_actions=onehot_actions.reshape(-1, 4),
-        rewards=rollout.rewards.ravel(),
-        advantages=advantages.ravel(),
-        value_targets=value_targets.ravel(),
-        log_action_probs=log_action_probs.ravel(),
-    )
-
-
-def loss_function(
-    network: SoftmaxPPONet,
-    batch: Batch,
-    ppo_clip_eps: float,
-) -> jax.Array:
-    net_out = jax.vmap(network)(batch.observations)
-    # Policy loss
-    log_pi = jax.nn.log_softmax(
-        jax.lax.select(
-            batch.action_masks,
-            net_out.policy_logits,
-            jnp.ones_like(net_out.policy_logits * -jnp.inf),
-        )
-    )
-    log_action_probs = jnp.sum(log_pi * batch.onehot_actions, axis=-1)
-    policy_ratio = jnp.exp(log_action_probs - batch.log_action_probs)
-    clipped_ratio = jnp.clip(policy_ratio, 1.0 - ppo_clip_eps, 1.0 + ppo_clip_eps)
-    clipped_objective = jnp.fmin(
-        policy_ratio * batch.advantages,
-        clipped_ratio * batch.advantages,
-    )
-    policy_loss = -jnp.mean(clipped_objective)
-    # Value loss
-    value_loss = jnp.mean(0.5 * (net_out.value - batch.value_targets) ** 2)
-    # Entropy regularization
-    entropy = jnp.mean(-jnp.exp(log_pi) * log_pi)
-    return policy_loss + value_loss - 0.01 * entropy
-
-
-vmapped_permutation = jax.vmap(jax.random.permutation, in_axes=(0, None), out_axes=0)
-
-
-@eqx.filter_jit
-def update_network(
-    batch: Batch,
-    network: SoftmaxPPONet,
-    optax_update: optax.TransformUpdateFn,
-    opt_state: optax.OptState,
-    prng_key: jax.Array,
-    minibatch_size: int,
-    n_epochs: int,
-    ppo_clip_eps: float,
-) -> tuple[optax.OptState, SoftmaxPPONet]:
-    # Prepare update function
-    dynamic_net, static_net = eqx.partition(network, eqx.is_array)
-
-    def update_once(
-        carried: tuple[optax.OptState, SoftmaxPPONet],
-        batch: Batch,
-    ) -> tuple[tuple[optax.OptState, SoftmaxPPONet], None]:
-        opt_state, dynamic_net = carried
-        network = eqx.combine(dynamic_net, static_net)
-        grad = eqx.filter_grad(loss_function)(network, batch, ppo_clip_eps)
-        updates, new_opt_state = optax_update(grad, opt_state)
-        dynamic_net = optax.apply_updates(dynamic_net, updates)
-        return (new_opt_state, dynamic_net), None
-
-    # Prepare minibatches
-    batch_size = batch.observations.shape[0]
-    permutations = vmapped_permutation(jax.random.split(prng_key, n_epochs), batch_size)
-    minibatches = jax.tree_map(
-        # Here, x's shape is [batch_size, ...]
-        lambda x: x[permutations].reshape(-1, minibatch_size, *x.shape[1:]),
-        batch,
-    )
-    # Update network n_epochs x n_minibatches times
-    (opt_state, updated_dynet), _ = jax.lax.scan(
-        update_once,
-        (opt_state, dynamic_net),
-        minibatches,
-    )
-    return opt_state, eqx.combine(updated_dynet, static_net)
-
-
-def run_training(
-    key: jax.Array,
-    adam_lr: float = 3e-4,
-    adam_eps: float = 1e-7,
-    gamma: float = 0.99,
-    gae_lambda: float = 0.95,
-    n_optim_epochs: int = 10,
-    minibatch_size: int = 1024,
-    n_agents: int = 16,
-    n_rollout_steps: int = 512,
-    n_total_steps: int = 16 * 512 * 100,
-    ppo_clip_eps: float = 0.2,
-    **env_kwargs,
-) -> SoftmaxPPONet:
-    key, net_key, reset_key = jax.random.split(key, 3)
-    pponet = SoftmaxPPONet(net_key)
-    env = AutoResetWrapper(jumanji.make("Maze-v0", **env_kwargs))
-    adam_init, adam_update = optax.adam(adam_lr, eps=adam_eps)
-    opt_state = adam_init(eqx.filter(pponet, eqx.is_array))
-    env_state, timestep = jax.vmap(env.reset)(jax.random.split(reset_key, 16))
-    obs = timestep.observation
-
-    n_loop = n_total_steps // (n_agents * n_rollout_steps)
-    return_reporting_interval = 1 if n_loop < 10 else n_loop // 10
-    n_episodes, reward_sum = 0.0, 0.0
-    for i in range(n_loop):
-        key, rollout_key, update_key = jax.random.split(key, 3)
-        env_state, rollout, obs, next_value = exec_rollout(
-            env_state,
-            obs,
-            env,
-            pponet,
-            rollout_key,
-            n_rollout_steps,
-        )
-        batch = make_batch(rollout, next_value, gamma, gae_lambda)
-        opt_state, pponet = update_network(
-            batch,
-            pponet,
-            adam_update,
-            opt_state,
-            update_key,
-            minibatch_size,
-            n_optim_epochs,
-            ppo_clip_eps,
-        )
-        n_episodes += jnp.sum(rollout.terminations).item()
-        reward_sum += jnp.sum(rollout.rewards).item()
-        if i > 0 and (i % return_reporting_interval == 0):
-            print(f"Mean episodic return: {reward_sum / n_episodes}")
-            n_episodes = 0.0
-            reward_sum = 0.0
-    return pponet
diff --git a/src/emevo/rl/ppo_normal.py b/src/emevo/rl/ppo_normal.py
new file mode 100644
index 00000000..1c3aeca9
--- /dev/null
+++ b/src/emevo/rl/ppo_normal.py
@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+from typing import NamedTuple
+
+import chex
+import distrax
+import equinox as eqx
+import jax
+import jax.numpy as jnp
+import optax
+from jax.nn.initializers import orthogonal
+
+
+class Output(NamedTuple):
+    mean: jax.Array
+    logstd: jax.Array
+    value: jax.Array
+
+
+class NormalPPONet(eqx.Module):
+    torso: list[eqx.Module]
+    value_head: eqx.nn.Linear
+    mean_head: eqx.nn.Linear
+    logstd_param: eqx.nn.Linear
+
+    def __init__(
+        self,
+        input_size: int,
+        hidden_size: int,
+        action_size: int,
+        key: jax.Array,
+    ) -> None:
+        key1, key2, key3, key4, key5 = jax.random.split(key, 5)
+        # Common layers
+        self.torso = [
+            eqx.nn.Linear(input_size, hidden_size, key=key1),
+            jnp.tanh,
+            eqx.nn.Linear(hidden_size, hidden_size, key=key2),
+            jnp.tanh,
+        ]
+        self.value_head = eqx.nn.Linear(hidden_size, 1, key=key3)
+        policy_head = eqx.nn.Linear(hidden_size, action_size, key=key4)
+        # Use small value for policy initialization
+        self.mean_head = eqx.tree_at(
+            lambda linear: linear.weight,
+            policy_head,
+            orthogonal(scale=0.01)(key5, policy_head.weight.shape),
+        )
+        self.logstd_param = jnp.zeros((action_size,))
+
+    def __call__(self, x: jax.Array) -> Output:
+        for layer in self.torso:
+            x = layer(x)
+        value = self.value_head(x)
+        mean = self.mean_head(x)
+        logstd = jnp.ones_like(mean) * self.logstd_param
+        return Output(mean=mean, logstd=logstd, value=value)
+
+    def value(self, x: jax.Array) -> jax.Array:
+        for layer in self.torso:
+            x = layer(x)
+        return self.value(x)
+
+
+@chex.dataclass
+class Rollout:
+    """Rollout buffer that stores the entire history of one rollout"""
+
+    observations: jax.Array
+    actions: jax.Array
+    rewards: jax.Array
+    terminations: jax.Array
+    values: jax.Array
+    means: jax.Array
+    logstds: jax.Array
+
+
+@chex.dataclass(frozen=True, mappable_dataclass=False)
+class Batch:
+    """Batch for PPO, indexable to get a minibatch."""
+
+    observations: jax.Array
+    actions: jax.Array
+    rewards: jax.Array
+    advantages: jax.Array
+    value_targets: jax.Array
+    log_action_probs: jax.Array
+
+    def __getitem__(self, idx: jax.Array):
+        return self.__class__(  # type: ignore
+            observations=self.observations[idx],
+            actions=self.actions[idx],
+            rewards=self.rewards[idx],
+            advantages=self.advantages[idx],
+            value_targets=self.value_targets[idx],
+            log_action_probs=self.log_action_probs[idx],
+        )
+
+
+def compute_gae(
+    r_t: jax.Array,
+    discount_t: jax.Array,
+    values: jax.Array,
+    lambda_: float = 0.95,
+) -> jax.Array:
+    """Efficiently compute generalized advantage estimator (GAE)"""
+
+    gamma_lambda_t = discount_t * lambda_
+    delta_t = r_t + discount_t * values[1:] - values[:-1]
+    n = delta_t.shape[0]
+
+    def update(i: int, advantage_t: jax.Array) -> jax.Array:
+        t = n - i - 1
+        adv_t = delta_t[t] + gamma_lambda_t[t] * advantage_t[t + 1]
+        return advantage_t.at[t].set(adv_t)
+
+    advantage_t = jax.lax.fori_loop(0, n, update, jnp.zeros_like(values))
+    return advantage_t[:-1]
+
+
+def make_inormal(mean: jax.Array, logstd: jax.Array) -> distrax.Distribution:
+    normal = distrax.LogStddevNormal(loc=mean, log_scale=logstd)
+    return distrax.Independent(normal, reinterpreted_batch_ndims=1)
+
+
+def make_batch(
+    rollout: Rollout,
+    next_value: jax.Array,
+    gamma: float,
+    gae_lambda: float,
+) -> Batch:
+    all_values = jnp.concatenate([rollout.values, next_value.reshape(1, -1)], axis=0)
+    advantages = compute_gae(
+        rollout.rewards,
+        # Set γ = 0 when the episode terminates
+        (1.0 - rollout.terminations) * gamma,
+        all_values,
+        gae_lambda,
+    )
+    value_targets = advantages + all_values[:-1]
+    actions = rollout.actions
+    log_action_probs = make_inormal(rollout.means, rollout.logstds).log_prob(actions)
+    return Batch(
+        observations=rollout.observations,
+        actions=actions,
+        # Convert (N, 1) shape to (N,)
+        rewards=rollout.rewards.ravel(),
+        advantages=advantages.ravel(),
+        value_targets=value_targets.ravel(),
+        log_action_probs=log_action_probs,
+    )
+
+
+def loss_function(
+    network: NormalPPONet,
+    batch: Batch,
+    ppo_clip_eps: float,
+    entropy_weight: float,
+) -> jax.Array:
+    net_out = jax.vmap(network)(batch.observations)
+    # Policy loss
+    policy_dist = make_inormal(net_out.mean, net_out.logstd)
+    log_prob = policy_dist.log_prob(batch.actions)
+    policy_ratio = jnp.exp(log_prob - batch.log_action_probs)
+    clipped_ratio = jnp.clip(policy_ratio, 1.0 - ppo_clip_eps, 1.0 + ppo_clip_eps)
+    clipped_objective = jnp.fmin(
+        policy_ratio * batch.advantages,
+        clipped_ratio * batch.advantages,
+    )
+    policy_loss = -jnp.mean(clipped_objective)
+    # Value loss
+    value_loss = jnp.mean(0.5 * (net_out.value - batch.value_targets) ** 2)
+    # Entropy regularization
+    entropy = jnp.mean(policy_dist.entropy())
+    return policy_loss + value_loss - entropy_weight * entropy
+
+
+vmapped_permutation = jax.vmap(jax.random.permutation, in_axes=(0, None), out_axes=0)
+
+
+def get_minibatches(
+    batch: Batch,
+    key: chex.PRNGKey,
+    minibatch_size: int,
+    n_epochs: int,
+) -> Batch:
+    batch_size = batch.observations.shape[0]
+    permutations = vmapped_permutation(jax.random.split(key, n_epochs), batch_size)
+
+    def get_minibatch_impl(x: jax.Array) -> jax.Array:
+        orig_shape = x.shape
+        x = x[permutations]
+        if len(orig_shape) == 1:
+            return x.reshape(-1, minibatch_size)
+        else:
+            return x.reshape(-1, minibatch_size, *orig_shape[1:])
+
+    return jax.tree_map(get_minibatch_impl, batch)
+
+
+def update_network(
+    batch: Batch,
+    network: NormalPPONet,
+    optax_update: optax.TransformUpdateFn,
+    opt_state: optax.OptState,
+    key: chex.PRNGKey,
+    minibatch_size: int,
+    n_epochs: int,
+    ppo_clip_eps: float,
+    entropy_weight: float,
+) -> tuple[optax.OptState, NormalPPONet]:
+    # Prepare update function
+    dynamic_net, static_net = eqx.partition(network, eqx.is_array)
+
+    def update_once(
+        carried: tuple[optax.OptState, NormalPPONet],
+        batch: Batch,
+    ) -> tuple[tuple[optax.OptState, NormalPPONet], None]:
+        opt_state, dynamic_net = carried
+        network = eqx.combine(dynamic_net, static_net)
+        grad = eqx.filter_grad(loss_function)(
+            network,
+            batch,
+            ppo_clip_eps,
+            entropy_weight,
+        )
+        updates, new_opt_state = optax_update(grad, opt_state)
+        dynamic_net = optax.apply_updates(dynamic_net, updates)
+        return (new_opt_state, dynamic_net), None
+
+    # Prepare minibatches
+    minibatches = get_minibatches(batch, key, minibatch_size, n_epochs)
+    # Update network n_epochs x n_minibatches times
+    (opt_state, updated_dynet), _ = jax.lax.scan(
+        update_once,
+        (opt_state, dynamic_net),
+        minibatches,
+    )
+    return opt_state, eqx.combine(updated_dynet, static_net)
diff --git a/tests/test_ppo.py b/tests/test_ppo.py
new file mode 100644
index 00000000..bb6b0da1
--- /dev/null
+++ b/tests/test_ppo.py
@@ -0,0 +1,85 @@
+import chex
+import equinox as eqx
+import jax
+import jax.numpy as jnp
+import optax
+import pytest
+
+from emevo.rl.ppo_normal import (
+    NormalPPONet,
+    Rollout,
+    get_minibatches,
+    make_batch,
+    update_network,
+)
+
+OBS_SIZE = 10
+ACT_SIZE = 4
+STEP_SIZE = 512
+MINIBATCH_SIZE = 64
+N_EPOCHS = 4
+N_MINIBATCHES = (STEP_SIZE // MINIBATCH_SIZE) * N_EPOCHS
+
+
+@pytest.fixture
+def key() -> chex.PRNGKey:
+    return jax.random.PRNGKey(43)
+
+
+def _rollout() -> Rollout:
+    return Rollout(
+        observations=jnp.zeros((STEP_SIZE, OBS_SIZE)),
+        actions=jnp.zeros((STEP_SIZE, ACT_SIZE)),
+        rewards=(jnp.arange(STEP_SIZE) % 3).astype(jnp.float32).reshape(-1, 1),
+        terminations=jnp.zeros((STEP_SIZE, 1), dtype=bool),
+        values=jnp.zeros((STEP_SIZE, 1)),
+        means=jnp.zeros((STEP_SIZE, ACT_SIZE)),
+        logstds=jnp.ones((STEP_SIZE, ACT_SIZE)),
+    )
+
+
+def test_make_batch() -> None:
+    rollout = _rollout()
+    batch = make_batch(rollout, jnp.zeros((1,)), 0.99, 0.95)
+    chex.assert_shape(batch.observations, (STEP_SIZE, OBS_SIZE))
+    chex.assert_shape(batch.actions, (STEP_SIZE, ACT_SIZE))
+    chex.assert_shape(batch.log_action_probs, (STEP_SIZE,))
+    chex.assert_shape(batch.rewards, (STEP_SIZE,))
+    chex.assert_shape(batch.advantages, (STEP_SIZE,))
+    chex.assert_shape(batch.value_targets, (STEP_SIZE,))
+
+
+def test_minibatches(key: chex.PRNGKey) -> None:
+    rollout = _rollout()
+    batch = make_batch(rollout, jnp.zeros((1,)), 0.99, 0.95)
+    minibatch = get_minibatches(batch, key, MINIBATCH_SIZE, N_EPOCHS)
+    prefix = N_MINIBATCHES, MINIBATCH_SIZE
+    chex.assert_shape(minibatch.observations, (*prefix, OBS_SIZE))
+    chex.assert_shape(minibatch.actions, (*prefix, ACT_SIZE))
+    chex.assert_shape(minibatch.log_action_probs, (*prefix,))
+    chex.assert_shape(minibatch.rewards, (*prefix,))
+    chex.assert_shape(minibatch.advantages, (*prefix,))
+    chex.assert_shape(minibatch.value_targets, (*prefix,))
+
+
+def test_update_network(key: chex.PRNGKey) -> None:
+    rollout = _rollout()
+    batch = make_batch(rollout, jnp.zeros((1,)), 0.99, 0.95)
+    key1, key2 = jax.random.split(key, 2)
+    pponet = NormalPPONet(OBS_SIZE, 5, ACT_SIZE, key1)
+    adam_init, adam_update = optax.adam(1e-3)
+    opt_state = adam_init(eqx.filter(pponet, eqx.is_array))
+    _, updated = update_network(
+        batch,
+        pponet,
+        adam_update,
+        opt_state,
+        key2,
+        64,
+        10,
+        0.1,
+        0.01,
+    )
+    before, _ = eqx.partition(pponet, eqx.is_array)
+    after, _ = eqx.partition(updated, eqx.is_array)
+    chex.assert_trees_all_equal_shapes(before, after)

From 70b18a2b774c3fe106e1a3e917b41fb5b26f86e2 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 8 Nov 2023 13:22:53 +0900
Subject: [PATCH 065/337] Remove outdated tests

---
 smoke-tests/circle_asexual_repr.py | 153 ---------------------------
 smoke-tests/circle_sexual_repr.py  | 162 -----------------------------
 smoke-tests/circle_widget.py       |  57 ----------
 3 files changed, 372 deletions(-)
 delete mode 100644 smoke-tests/circle_asexual_repr.py
 delete mode 100644 smoke-tests/circle_sexual_repr.py
 delete mode 100644 smoke-tests/circle_widget.py

diff --git a/smoke-tests/circle_asexual_repr.py b/smoke-tests/circle_asexual_repr.py
deleted file mode 100644
index 9dff6af5..00000000
--- a/smoke-tests/circle_asexual_repr.py
+++ /dev/null
@@ -1,153 +0,0 @@
-"""Example of asexual reproduction in circle foraging environment"""
-from __future__ import annotations
-
-import enum
-import sys
-from functools import partial
-from pathlib import Path
-
-import numpy as np
-import typer
-from loguru import logger
-from numpy.random import PCG64
-from pymunk.vec2d import Vec2d
-
-from emevo import Status
-from emevo import birth_and_death as bd
-from emevo import make
-from emevo import visualizer as evis
-from emevo._test_utils import sample_location
-
-
-class Rendering(str, enum.Enum):
-    PYGAME = "pygame"
-    MODERNGL = "moderngl"
-    HEADLESS = "headless"
-
-
-class HazardFn(str, enum.Enum):
-    CONST = "const"
-    GOMPERTZ = "gompertz"
-
-
-def main(
-    steps: int = 100,
-    render: Rendering | None = None,
-    food_initial_force: tuple[float, float] = (0.0, 0.0),
-    agent_radius: float = 12.0,
-    n_agent_sensors: int = 8,
-    sensor_length: float = 10.0,
-    env_shape: str = "square",
-    seed: int = 1,
-    hazard: HazardFn = HazardFn.CONST,
-    debug: bool = False,
-    video: Path | None = None,
-) -> None:
-    if debug:
-        logger.enable("emevo")
-    logger.add(
-        sys.stderr,
-        filter="__main__",
-        level="DEBUG" if debug else "INFO",
-    )
-
-    avg_lifetime = steps // 2
-    if hazard == HazardFn.CONST:
-        hazard_fn = bd.death.Constant(
-            alpha_const=1.0 / avg_lifetime,
-            alpha_energy=1.0 / avg_lifetime,
-            gamma=0.1,
-        )
-    elif hazard == HazardFn.GOMPERTZ:
-        hazard_fn = bd.death.Gompertz(
-            alpha_const=1.0 / avg_lifetime,
-            alpha_energy=1.0 / avg_lifetime,
-            gamma=0.1,
-            beta=1e-4,
-        )
-    else:
-        raise ValueError(f"Invalid hazard {hazard}")
-    birth_fn = bd.birth.Logistic(
-        scale=10.0 / avg_lifetime,
-        alpha=0.1,
-        beta=10.0 / avg_lifetime,
-        age_delay=avg_lifetime / 4,
-        energy_delay=0.0,
-    )
-    exp_n_children = bd.population.expected_n_children(
-        birth=birth_fn,
-        hazard=hazard_fn,
-        energy=1.0,
-    )
-    logger.info(f"Expected num. of children: {exp_n_children}")
-
-    manager = bd.AsexualReprManager(
-        initial_status_fn=partial(Status, age=1, energy=4.0),
-        hazard_fn=hazard_fn,
-        birth_fn=birth_fn.asexual,
-        produce_fn=lambda status, body: bd.Oviparous(
-            parent=body,
-            parental_status=status,
-            time_to_birth=5,
-        ),
-    )
-
-    env = make(
-        "CircleForaging-v0",
-        food_initial_force=food_initial_force,
-        n_agent_sensors=n_agent_sensors,
-        sensor_length=sensor_length,
-        env_shape=env_shape,
-    )
-    manager.register(env.bodies())
-    gen = np.random.Generator(PCG64(seed=seed))
-
-    if render is not None:
-        if render == Rendering.HEADLESS:
-            visualizer = env.visualizer(mode="moderngl", mgl_backend="headless")
-        else:
-            visualizer = env.visualizer(mode=render.value)
-        if video is not None:
-            visualizer = evis.SaveVideoWrapper(visualizer, video, fps=60)
-    else:
-        visualizer = None
-
-    for i in range(steps):
-        bodies = env.bodies()
-        actions = {body: body.act_space.sample(gen) for body in bodies}
-        _ = env.step(actions)
-        for body in bodies:
-            action_cost = np.linalg.norm(actions[body]) * 0.01
-            observation = env.observe(body)
-            energy_delta = observation.n_collided_foods - action_cost
-            manager.update_status(body, energy_delta=energy_delta)
-        manager.reproduce(bodies)
-        deads, newborns = manager.step()
-
-        for dead in deads:
-            logger.info(f"{dead.body} is dead with {dead.status}")
-            env.remove_body(dead.body)
-
-        for newborn in newborns:
-            loc = sample_location(
-                gen,
-                newborn.location(),
-                radius_max=agent_radius * 3,
-                radius_min=agent_radius * 1.5,
-            )
-            body = env.locate_body(Vec2d(*loc), newborn.parent.generation + 1)
-            if body is not None:
-                logger.info(f"{body} was born")
-                manager.register(body)
-
-        if visualizer is not None:
-            visualizer.render(env)
-            visualizer.show()
-
-        if env.is_extinct():
-            logger.info(f"Extinct after {i} steps")
-            break
-
-
-if __name__ == "__main__":
-    typer.run(main)
diff --git a/smoke-tests/circle_sexual_repr.py b/smoke-tests/circle_sexual_repr.py
deleted file mode 100644
index 40efddb0..00000000
--- a/smoke-tests/circle_sexual_repr.py
+++ /dev/null
@@ -1,162 +0,0 @@
-"""Example of sexual reproduction in circle foraging environment"""
-from __future__ import annotations
-
-import dataclasses
-import enum
-import sys
-from functools import partial
-
-import numpy as np
-import typer
-from loguru import logger
-from numpy.random import PCG64
-from pymunk.vec2d import Vec2d
-
-from emevo import Encount, Status
-from emevo import birth_and_death as bd
-from emevo import make
-from emevo._test_utils import sample_location
-
-
-@dataclasses.dataclass
-class SimpleContext:
-    generation: int
-    location: Vec2d
-
-
-class HazardFn(str, enum.Enum):
-    CONST = "const"
-    GOMPERTZ = "gompertz"
-
-
-class Rendering(str, enum.Enum):
-    PYGAME = "pygame"
-    MODERNGL = "moderngl"
-
-
-def birth_fn(status_a: Status, status_b: Status) -> float:
-    avg_energy = (status_a.energy + status_b.energy) / 2.0
-    return 1 / (1.0 + np.exp(-avg_energy))
-
-
-def main(
-    steps: int = 100,
-    render: Rendering | None = None,
-    food_initial_force: tuple[float, float] = (0.0, 0.0),
-    agent_radius: float = 12.0,
-    n_agent_sensors: int = 8,
-    sensor_length: float = 10.0,
-    env_shape: str = "square",
-    seed: int = 1,
-    hazard: HazardFn = HazardFn.CONST,
-    debug: bool = False,
-) -> None:
-    logger.remove()
-    if debug:
-        logger.enable("emevo")
-    logger.add(
-        sys.stderr,
-        filter="__main__",
-        level="DEBUG" if debug else "INFO",
-    )
-
-    avg_lifetime = steps // 2
-    if hazard == HazardFn.CONST:
-        hazard_fn = bd.death.Constant(
-            alpha_const=1.0 / avg_lifetime,
-            alpha_energy=1.0 / avg_lifetime,
-            gamma=0.1,
-        )
-    elif hazard == HazardFn.GOMPERTZ:
-        hazard_fn = bd.death.Gompertz(
-            alpha_const=1.0 / avg_lifetime,
-            alpha_energy=1.0 / avg_lifetime,
-            gamma=0.1,
-            beta=1e-4,
-        )
-    else:
-        raise ValueError(f"Invalid hazard {hazard}")
-
-    birth_fn = bd.birth.Logistic(
-        scale=0.1,
-        alpha=0.1,
-        beta=10.0 / avg_lifetime,
-        age_delay=avg_lifetime / 4,
-        energy_delay=0.0,
-    )
-
-    def produce(sa: Status, sb: Status, encount: Encount) -> bd.Oviparous:
-        return bd.Oviparous(
-            parent=encount.a,
-            parental_status=(sa, sb),
-            time_to_birth=5,
-        )
-
-    manager = bd.SexualReprManager(
-        initial_status_fn=partial(Status, age=1, energy=0.0),
-        hazard_fn=hazard_fn,
-        birth_fn=birth_fn.sexual,
-        produce_fn=produce,
-    )
-
-    env = make(
-        "CircleForaging-v0",
-        food_initial_force=food_initial_force,
-        agent_radius=agent_radius,
-        n_agent_sensors=n_agent_sensors,
-        sensor_length=sensor_length,
-        env_shape=env_shape,
-    )
-    manager.register(env.bodies())
-    gen = np.random.Generator(PCG64(seed=seed))
-
-    if render is not None:
-        visualizer = env.visualizer(mode=render.value)
-    else:
-        visualizer = None
-
-    for i in range(steps):
-        bodies = env.bodies()
-        actions = {body: body.act_space.sample(gen) for body in bodies}
-        logger.debug("Step start")
-        encounts = env.step(actions)
-        logger.debug("Step end")
-        for body in bodies:
-            action_cost = np.linalg.norm(actions[body]) * 0.01
-            logger.debug("Observe start")
-            observation = env.observe(body)
-            logger.debug("Observe end")
-            energy_delta = observation.n_collided_foods - action_cost
-            manager.update_status(body, energy_delta=energy_delta)
-        _ = manager.reproduce(encounts)
-        deads, newborns = manager.step()
-
-        for dead in deads:
-            logger.info(f"{dead.body} is dead with {dead.status}")
-            env.remove_body(dead.body)
-
-        for newborn in newborns:
-            loc = sample_location(
-                gen,
-                newborn.location(),
-                radius_max=agent_radius * 3,
-                radius_min=agent_radius * 1.5,
-            )
-            body = env.locate_body(Vec2d(*loc), newborn.parent.generation + 1)
-            if body is not None:
-                logger.info(f"{body} was born")
-                manager.register(body)
-            if body is not None:
-                manager.register(body)
-
-        if visualizer is not None:
-            visualizer.render(env)
-            visualizer.show()
-
-        if env.is_extinct():
-            logger.info(f"Extinct after {i} steps")
-            break
-
-
-if __name__ == "__main__":
-    typer.run(main)
diff --git a/smoke-tests/circle_widget.py b/smoke-tests/circle_widget.py
deleted file mode 100644
index 2ceea42d..00000000
--- a/smoke-tests/circle_widget.py
+++ /dev/null
@@ -1,57 +0,0 @@
-"""Example of using circle foraging environment"""
-from __future__ import annotations
-
-import sys
-
-import numpy as np
-import typer
-from numpy.random import PCG64
-from PySide6 import QtWidgets
-from PySide6.QtCore import QTimer
-
-from emevo import make
-from emevo.environments.pymunk_envs.qt_widget import AppState, PymunkMglWidget
-
-
-def main(
-    seed: int = 1,
-    debug: bool = False,
-    fps: int = 40,
-    env_shape: str = "square",
-) -> None:
-    if debug:
-        import loguru
-
-        loguru.logger.enable("emevo")
-
-    env = make(
-        "CircleForaging-v0",
-        env_shape=env_shape,
-        sensor_range=(-60, 60),
-        sensor_length=60,
-        max_abs_angle=np.pi / 20,
-        seed=seed,
-    )
-    bodies = env.bodies()
-    gen = np.random.Generator(PCG64(seed=seed))
-
-    def step_fn(state: AppState):
-        if not state.paused:
-            actions = {body: body.act_space.sample(gen) for body in bodies}
-            env.step(actions)
-
-    app = QtWidgets.QApplication([])
-    timer = QTimer()
-    widget = PymunkMglWidget(
-        env=env,  # type: ignore
-        figsize=(640, 640),
-        step_fn=step_fn,
-        timer=timer,
-    )
-    timer.start(1000 // fps)  # 40fps
-    widget.show()
-    sys.exit(app.exec())
-
-
-if __name__ == "__main__":
-    typer.run(main)

From df86b6b5aba3c0e45b1e07eacf07e2c8d1cebcc7 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 8 Nov 2023 17:40:11 +0900
Subject: [PATCH 066/337] Implement food

---
 smoke-tests/circle_loop.py                |  14 +-
 src/emevo/environments/circle_foraging.py | 158 ++++++++++++++++++++--
 src/emevo/environments/moderngl_vis.py    |   8 +-
 src/emevo/environments/phyjax2d.py        |  12 +-
 4 files changed, 163 insertions(+), 29 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index ddba7959..9c824362 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -1,34 +1,23 @@
 """Example of using circle foraging environment"""
 
 import datetime
-import enum
-from typing import Any, Optional, Tuple
 
-import chex
 import jax
 import numpy as np
 import typer
-from numpy.random import PCG64
 from tqdm import tqdm
 
 
 from emevo import make
 
 
-class FoodNum(str, enum.Enum):
-    CONSTANT = "constant"
-    LINEAR = "linear"
-    LOGISTIC = "logistic"
-
 
 def main(
     steps: int = 100,
     seed: int = 1,
     n_agents: int = 10,
     n_foods: int = 10,
-    forward_sensor: bool = False,
-    use_test_env: bool = False,
-    obstacles: bool = False,
+    obstacles: str = "none",
     render: bool = False,
     replace: bool = False,
     fixed_agent_loc: bool = False,
@@ -58,6 +47,7 @@ def main(
         food_num_fn=("constant", n_foods),
         food_loc_fn=food_loc_fn,
         foodloc_interval=20,
+        obstacles=obstacles,
         **additional_kwargs,
     )
     key = jax.random.PRNGKey(seed)
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 2cfc0a2b..5a6f2772 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import enum
 import functools
 import warnings
 from typing import Any, Callable, Literal, NamedTuple
@@ -48,6 +49,7 @@
 MAX_FORCE: float = 1.0
 AGENT_COLOR: Color = Color(2, 204, 254)
 FOOD_COLOR: Color = Color(254, 2, 162)
+NOWHERE: float = -100.0
 
 
 class CFObs(NamedTuple):
@@ -92,6 +94,44 @@ def is_extinct(self) -> bool:
         return jnp.logical_not(jnp.any(self.profile.is_active())).item()
 
 
+class Obstacle(str, enum.Enum):
+    NONE = "none"
+    CENTER = "center"
+    CENTER_HALF = "center-half"
+    CENTER_SHORT = "center-short"
+
+    def as_list(
+        self,
+        width: float,
+        height: float,
+    ) -> list[tuple[Vec2d, Vec2d]]:
+        # xmin, xmax, ymin, ymax
+        if self == Obstacle.NONE:
+            return []
+        elif self == Obstacle.CENTER:
+            return [(Vec2d(width / 2, height / 4), Vec2d(width / 2, height))]
+        elif self == Obstacle.CENTER_HALF:
+            return [(Vec2d(width / 2, height / 2), Vec2d(width / 2, height))]
+        elif self == Obstacle.CENTER_SHORT:
+            return [(Vec2d(width / 2, height / 3), Vec2d(width / 2, height))]
+        else:
+            raise ValueError(f"Unsupported Obstacle: {self}")
+
+
+class SensorRange(str, enum.Enum):
+    NARROW = "narrow"
+    WIDE = "wide"
+    ALL = "all"
+
+    def as_tuple(self) -> tuple[float, float]:
+        if self == SensorRange.NARROW:
+            return -30.0, 30.0
+        elif self == SensorRange.WIDE:
+            return -60.0, 60.0
+        else:
+            return -180.0, 180.0
+
+
 def _get_num_or_loc_fn(
     arg: str | tuple | list | Callable[..., Any],
     enum_type: Callable[..., Callable[..., Any]],
@@ -119,6 +159,7 @@ def _make_physics(
     n_max_foods: int = 20,
     agent_radius: float = 10.0,
     food_radius: float = 4.0,
+    obstacles: list[tuple[Vec2d, Vec2d]] | None = None,
 ) -> tuple[Physics, State]:
     builder = SpaceBuilder(
         gravity=(0.0, 0.0),  # No gravity
@@ -132,15 +173,17 @@ def _make_physics(
     )
     # Set walls
     if isinstance(coordinate, CircleCoordinate):
-        outer_walls = make_approx_circle(coordinate.center, coordinate.radius)
+        walls = make_approx_circle(coordinate.center, coordinate.radius)
     else:
-        outer_walls = make_square(
+        walls = make_square(
             *coordinate.xlim,
             *coordinate.ylim,
             rounded_offset=np.floor(food_radius * 2 / (np.sqrt(2) - 1.0)),
         )
+    if obstacles is not None:
+        walls += obstacles
     segments = []
-    for wall in outer_walls:
+    for wall in walls:
         a2b = wall[1] - wall[0]
         angle = jnp.array(a2b.angle)
         xy = jnp.array(wall[0] + wall[1]) / 2
@@ -149,6 +192,7 @@ def _make_physics(
         builder.add_segment(length=a2b.length, friction=0.1, elasticity=0.2)
     seg_position = jax.tree_map(lambda *args: jnp.stack(args), *segments)
     seg_state = State.from_position(seg_position)
+    # Prepare agents
     for _ in range(n_max_agents):
         builder.add_circle(
             radius=agent_radius,
@@ -157,6 +201,7 @@ def _make_physics(
             density=0.04,
             color=AGENT_COLOR,
         )
+    # Prepare foods
     for _ in range(n_max_foods):
         builder.add_circle(
             radius=food_radius,
@@ -252,10 +297,10 @@ def __init__(
         ylim: tuple[float, float] = (0.0, 200.0),
         env_radius: float = 120.0,
         env_shape: Literal["square", "circle"] = "square",
-        obstacles: list[tuple[float, float, float, float]] | None = None,
+        obstacles: list[tuple[Vec2d, Vec2d]] | str = "none",
         n_agent_sensors: int = 8,
         sensor_length: float = 10.0,
-        sensor_range: tuple[float, float] = (-120.0, 120.0),
+        sensor_range: tuple[float, float] | SensorRange = SensorRange.WIDE,
         agent_radius: float = 10.0,
         food_radius: float = 4.0,
         foodloc_interval: int = 1000,
@@ -300,6 +345,11 @@ def __init__(
         self._n_max_foods = n_max_foods
         self._max_place_attempts = max_place_attempts
         # Physics
+        if isinstance(obstacles, str):
+            obs_list = Obstacle(obstacles).as_list(self._x_range, self._y_range)
+        else:
+            obs_list = obstacles
+
         self._physics, self._segment_state = _make_physics(
             dt=dt,
             coordinate=self._coordinate,
@@ -311,6 +361,7 @@ def __init__(
             n_max_foods=n_max_foods,
             agent_radius=agent_radius,
             food_radius=food_radius,
+            obstacles=obs_list,
         )
         self._agent_indices = jnp.arange(n_max_agents)
         self._food_indices = jnp.arange(n_max_foods)
@@ -329,7 +380,7 @@ def __init__(
         # Obs
         self._n_sensors = n_agent_sensors
         # Some cached constants
-        self._invisible_xy = jnp.array([-100.0, -100.0], dtype=jnp.float32)
+        self._invisible_xy = jnp.ones(2) * NOWHERE
         act_p1 = Vec2d(0, agent_radius).rotated(np.pi * 0.75)
         act_p2 = Vec2d(0, agent_radius).rotated(-np.pi * 0.75)
         N = self._n_max_agents
@@ -355,12 +406,16 @@ def __init__(
                 shaped=self._physics.shaped,
             )
         )
+        if isinstance(sensor_range, SensorRange):
+            sensor_range_tuple = SensorRange(sensor_range).as_tuple()
+        else:
+            sensor_range_tuple = sensor_range
         self._sensor_obs = jax.jit(
             functools.partial(
                 get_sensor_obs,
                 shaped=self._physics.shaped,
                 n_sensors=n_agent_sensors,
-                sensor_range=sensor_range,
+                sensor_range=sensor_range_tuple,
                 sensor_length=sensor_length,
             )
         )
@@ -452,14 +507,16 @@ def step(
         circle = circle.apply_force_local(self._act_p2, f2)
         stated = state.physics.replace(circle=circle)
         # Step physics simulator
-        stated, solver, contacts = nstep(
+        stated, solver, nstep_contacts = nstep(
             self._n_physics_iter,
             self._physics,
             stated,
             state.solver,
         )
-        contacts = jnp.max(contacts, axis=0)
+        # Gather circle contacts
+        contacts = jnp.max(nstep_contacts, axis=0)
         circle_contacts = self._physics.get_specific_contact("circle", contacts)
+        # Gather sensor obs
         sensor_obs = self._sensor_obs(stated=stated)
         obs = CFObs(
             sensor=sensor_obs.reshape(-1, self._n_sensors, 3),
@@ -470,6 +527,27 @@ def step(
         )
         encount = self._physics.get_contact_mat("circle", "circle", contacts)
         timestep = TimeStep(encount=encount, obs=obs)
+        # Remove and reproduce foods
+        food_contacts = self._physics.get_contact_mat(
+            "circle",
+            "static_circle",
+            contacts,
+        )
+        key, food_key = jax.random.split(state.key)
+        stated, food_num, food_loc = self._remove_and_reproduce_foods(
+            food_key,
+            jnp.max(food_contacts, axis=0),
+            stated,
+            state.food_num,
+            state.food_loc,
+        )
+        state = state.replace(
+            physics=stated,
+            solver=solver,
+            food_num=food_num,
+            food_loc=food_loc,
+            key=key,
+        )
         return state.replace(physics=stated, solver=solver), timestep
 
     def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:
@@ -567,11 +645,11 @@ def _initialize_physics_state(
         # Move all circle to the invisiable area
         stated = stated.nested_replace(
             "circle.p.xy",
-            jnp.ones_like(stated.circle.p.xy) * -100,
+            jnp.ones_like(stated.circle.p.xy) * NOWHERE,
         )
         stated = stated.nested_replace(
             "static_circle.p.xy",
-            jnp.ones_like(stated.static_circle.p.xy) * -100,
+            jnp.ones_like(stated.static_circle.p.xy) * NOWHERE,
         )
         keys = jax.random.split(key, self._n_initial_agents + self._n_initial_foods)
         agent_failed = 0
@@ -609,6 +687,64 @@ def _initialize_physics_state(
         stated = stated.replace(segment=self._segment_state)
         return stated, agentloc_state, foodloc_state
 
+    def _remove_and_reproduce_foods(
+        self,
+        key: chex.PRNGKey,
+        eaten: jax.Array,
+        sd: StateDict,
+        food_num: FoodNumState,
+        food_loc: LocatingState,
+    ) -> tuple[StateDict, FoodNumState, LocatingState]:
+        def remove_food(eaten: jax.Array, sd: StateDict) -> StateDict:
+            xy = jnp.where(
+                jnp.expand_dims(eaten, axis=1),
+                sd.static_circle.p.xy,
+                jnp.ones_like(sd.static_circle.p.xy) * NOWHERE,
+            )
+            is_active = jnp.logical_and(
+                sd.static_circle.is_active,
+                jnp.logical_not(eaten),
+            )
+            sd = sd.nested_replace("static_circle.p.xy", xy)
+            return sd.nested_replace("static_circle.is_active", is_active)
+
+        n_eaten = jnp.sum(eaten)
+        sd = jax.lax.cond(n_eaten > 0, remove_food, lambda _, sd: sd, eaten, sd)
+        food_num = self._food_num_fn(food_num.eaten(n_eaten))
+
+        def try_place_food() -> tuple[StateDict, FoodNumState, LocatingState]:
+            (index,) = jnp.nonzero(
+                jnp.logical_not(sd.static_circle.is_active),
+                size=1,
+                fill_value=-1,
+            )
+            index = index[0]
+            xy = self._place_food(loc_state=food_loc, key=key, stated=sd)
+
+            def success(xy: jax.Array) -> tuple[StateDict, FoodNumState, LocatingState]:
+                xy = sd.static_circle.p.xy.at[index].set(xy)
+                angle = sd.static_circle.p.angle.at[index].set(0.0)
+                p = Position(angle=angle, xy=xy)
+                is_active = sd.static_circle.is_active.at[index].set(True)
+                static_circle = sd.static_circle.replace(p=p, is_active=is_active)
+                return (
+                    sd.replace(static_circle=static_circle),
+                    food_num.recover(1),
+                    food_loc.increment(),
+                )
+
+            def failure(xy: jax.Array) -> tuple[StateDict, FoodNumState, LocatingState]:
+                return sd, food_num, food_loc
+
+            ok = jnp.logical_and(index >= 0, jnp.all(xy < jnp.inf))
+            return jax.lax.cond(ok, success, failure, xy)
+
+        return jax.lax.cond(
+            food_num.appears(),
+            try_place_food,
+            lambda: (sd, food_num, food_loc),
+        )
+
     def visualizer(
         self,
         state: CFState,
diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index 3b8e01a7..5e2a37ec 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -455,11 +455,17 @@ def render(self, stated: StateDict) -> None:
             stated.circle,
             self._circle_scaling,
         )
+        static_circles = _collect_circles(
+            self._space.shaped.static_circle,
+            stated.static_circle,
+            self._circle_scaling,
+        )
         if self._circles.update(*circles):
             self._circles.render()
+        if self._static_circles.update(*static_circles):
+            self._static_circles.render()
         if self._heads.update(_collect_heads(self._space.shaped.circle, stated.circle)):
             self._heads.render()
-        self._static_circles.render()
         self._static_lines.render()
 
 
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 6937f6e9..6ea35408 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -681,10 +681,12 @@ def get_specific_contact(self, name: str, contact: jax.Array) -> jax.Array:
                 has_contact = jnp.zeros(n, dtype=bool)
                 from_, to = contact_offset
                 cont = contact[from_:to]
-                if n1 == name:
-                    has_contact = has_contact.at[idx1[from_:to]].max(cont)
-                if n2 == name:
-                    has_contact = has_contact.at[idx2[from_:to]].max(cont)
+                if n1 == n2:
+                    has_contact = cont[idx1[from_:to]].at[idx2[from_:to]].max(cont)
+                elif n1 == name:
+                    has_contact = cont[idx1[from_:to]]
+                else:
+                    has_contact = cont[idx2[from_:to]]
                 has_contact_list.append(has_contact[offset : offset + size])
         return jnp.stack(has_contact_list, axis=1)
 
@@ -959,7 +961,7 @@ def solve_constraints(
     idx1, idx2 = space._ci_total.index1, space._ci_total.index2
 
     def gather(a: jax.Array, b: jax.Array, orig: jax.Array) -> jax.Array:
-        return orig.at[idx1].add(a, indices_are_sorted=True).at[idx2].add(b)
+        return orig.at[idx1].add(a).at[idx2].add(b)
 
     p1, p2 = p.get_slice(idx1), p.get_slice(idx2)
     v1, v2 = v.get_slice(idx1), v.get_slice(idx2)

From 1477059829fa9d8a1554111c5e4e40364f3db53e Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Thu, 9 Nov 2023 13:56:41 +0900
Subject: [PATCH 067/337] Start implementing circle_ppo

---
 smoke-tests/circle_loop.py                |  32 ------
 smoke-tests/circle_ppo.py                 | 127 ++++++++++++++++++++++
 src/emevo/env.py                          |  19 +++-
 src/emevo/environments/circle_foraging.py |  37 +++----
 4 files changed, 157 insertions(+), 58 deletions(-)
 create mode 100644 smoke-tests/circle_ppo.py

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index 9c824362..b1989ce7 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -7,11 +7,9 @@
 import typer
 from tqdm import tqdm
 
-
 from emevo import make
 
 
-
 def main(
     steps: int = 100,
     seed: int = 1,
@@ -59,36 +57,6 @@ def main(
     else:
         visualizer = None
 
-    activate_index = n_agents
-    jit_step = jax.jit(env.step)
-    jit_sample = jax.jit(env.act_space.sample)
-    elapsed_list = []
-    for i, key in tqdm(zip(range(steps), keys[1:])):
-        before = datetime.datetime.now()
-        state, _ = jit_step(state, jit_sample(key))
-        elapsed = datetime.datetime.now() - before
-        if i == 0:
-            print(f"Compile: {elapsed.total_seconds()}s")
-        elif i > 10:
-            elapsed_list.append(elapsed / datetime.timedelta(microseconds=1))
-        if replace and i % 1000 == 0:
-            if n_agents + 5 <= activate_index:
-                state, success = env.deactivate(state, activate_index)
-                if not success:
-                    print(f"Failed to deactivate agent! {activate_index}")
-                else:
-                    activate_index -= 1
-            else:
-                state, success = env.activate(state, 0)
-                if not success:
-                    print("Failed to activate agent!")
-                else:
-                    activate_index += 1
-
-        if visualizer is not None:
-            visualizer.render(state)
-            visualizer.show()
-
     print(f"Avg. μs for step: {np.mean(elapsed_list)}")
 
 
diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
new file mode 100644
index 00000000..9359d8df
--- /dev/null
+++ b/smoke-tests/circle_ppo.py
@@ -0,0 +1,127 @@
+"""Example of using circle foraging environment"""
+
+import datetime
+
+import jax
+import numpy as np
+import typer
+from tqdm import tqdm
+
+from emevo import make, env:
+from emevo.rl.ppo import NormalPPONet
+
+
+def run_training(key: jax.Array, n_agents: int, env: Env) -> NormalPPONet:
+    key, net_key, reset_key = jax.random.split(key, 3)
+    pponet = jax.vmap(NormalPPONet)(jax.random.split(net_key, n_agents))
+    adam_init, adam_update = optax.adam(adam_lr, eps=adam_eps)
+    opt_state = adam_init(eqx.filter(pponet, eqx.is_array))
+    env_state, timestep = env.reset()
+    obs = timestep.observation
+
+    n_loop = n_total_steps // (n_agents * n_rollout_steps)
+    return_reporting_interval = 1 if n_loop < 10 else n_loop // 10
+    n_episodes, reward_sum = 0.0, 0.0
+    for i in range(n_loop):
+        key, rollout_key, update_key = jax.random.split(key, 3)
+        env_state, rollout, obs, next_value = exec_rollout(
+            env_state,
+            obs,
+            env,
+            pponet,
+            rollout_key,
+            n_rollout_steps,
+        )
+        batch = make_batch(rollout, next_value, gamma, gae_lambda)
+        opt_state, pponet = update_network(
+            batch,
+            pponet,
+            adam_update,
+            opt_state,
+            update_key,
+            minibatch_size,
+            n_optim_epochs,
+            ppo_clip_eps,
+        )
+        n_episodes += jnp.sum(rollout.terminations).item()
+        reward_sum += jnp.sum(rollout.rewards).item()
+        if i > 0 and (i % return_reporting_interval == 0):
+            print(f"Mean episodic return: {reward_sum / n_episodes}")
+            n_episodes = 0.0
+            reward_sum = 0.0
+    return pponet
+
+
+def main(
+    steps: int = 100,
+    seed: int = 1,
+    n_agents: int = 10,
+    n_foods: int = 10,
+    obstacles: str = "none",
+    render: bool = False,
+    replace: bool = False,
+    adam_lr: float = 3e-4,
+    adam_eps: float = 1e-7,
+    gamma: float = 0.99,
+    gae_lambda: float = 0.95,
+    n_optim_epochs: int = 10,
+    minibatch_size: int = 1024,
+    n_rollout_steps: int = 512,
+    n_total_steps: int = 16 * 512 * 100,
+    ppo_clip_eps: float = 0.2,
+    food_loc_fn: str = "gaussian",
+) -> None:
+    env = make(
+        "CircleForaging-v0",
+        env_shape=env_shape,
+        n_max_agents=n_agents + 1,
+        n_initial_agents=n_agents,
+        food_num_fn=("constant", n_foods),
+        food_loc_fn=food_loc_fn,
+        foodloc_interval=20,
+        obstacles=obstacles,
+    )
+    key = jax.random.PRNGKey(seed)
+    keys = jax.random.split(key, steps + 1)
+    state = env.reset(keys[0])
+
+    if render:
+        visualizer = env.visualizer(state)
+    else:
+        visualizer = None
+
+    activate_index = n_agents
+    jit_step = jax.jit(env.step)
+    jit_sample = jax.jit(env.act_space.sample)
+    elapsed_list = []
+    for i, key in tqdm(zip(range(steps), keys[1:])):
+        before = datetime.datetime.now()
+        state, _ = jit_step(state, jit_sample(key))
+        elapsed = datetime.datetime.now() - before
+        if i == 0:
+            print(f"Compile: {elapsed.total_seconds()}s")
+        elif i > 10:
+            elapsed_list.append(elapsed / datetime.timedelta(microseconds=1))
+        if replace and i % 1000 == 0:
+            if n_agents + 5 <= activate_index:
+                state, success = env.deactivate(state, activate_index)
+                if not success:
+                    print(f"Failed to deactivate agent! {activate_index}")
+                else:
+                    activate_index -= 1
+            else:
+                state, success = env.activate(state, 0)
+                if not success:
+                    print("Failed to activate agent!")
+                else:
+                    activate_index += 1
+
+        if visualizer is not None:
+            visualizer.render(state)
+            visualizer.show()
+
+    print(f"Avg. μs for step: {np.mean(elapsed_list)}")
+
+
+if __name__ == "__main__":
+    typer.run(main)
diff --git a/src/emevo/env.py b/src/emevo/env.py
index b2ca2de6..38d985c7 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -68,9 +68,6 @@ def init_profile(n: int, max_n: int) -> Profile:
 
 
 class StateProtocol(Protocol):
-    """Each state should have PRNG key"""
-
-    key: chex.PRNGKey
     step: jax.Array
     profile: Profile
     n_born_agents: jax.Array
@@ -88,6 +85,7 @@ class ObsProtocol(Protocol):
     def as_array(self) -> jax.Array:
         ...
 
+
 OBS = TypeVar("OBS", bound="ObsProtocol")
 
 
@@ -122,17 +120,26 @@ def step(self, state: STATE, action: ArrayLike) -> tuple[STATE, TimeStep[OBS]]:
         pass
 
     @abc.abstractmethod
-    def activate(self, state: STATE, parent_gen: int | jax.Array) -> tuple[STATE, bool]:
-        """Mark an agent or some agents active."""
+    def activate(
+        self,
+        key: chex.PRNGKey,
+        state: STATE,
+        parent_gen: int | jax.Array,
+    ) -> tuple[STATE, bool]:
+        """
+        Mark an agent or some agents active.
+        This method fails if there isn't enough space, returning (STATE, False).
+        """
         pass
 
     @abc.abstractmethod
-    def deactivate(self, state: STATE, index: Index) -> tuple[STATE, bool]:
+    def deactivate(self, state: STATE, index: Index) -> STATE:
         """
         Deactivate an agent or some agents. The shape of observations should remain the
         same so that `Env.step` is compiled onle once. So, to represent that an agent is
         dead, it is recommended to mark that body is not active and reuse it after a new
         agent is born.
+        This method should not fail.
         """
         pass
 
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 5a6f2772..6b4c3d98 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -81,7 +81,6 @@ class CFState:
     food_num: FoodNumState
     agent_loc: LocatingState
     food_loc: LocatingState
-    key: chex.PRNGKey
     step: jax.Array
     profile: Profile
     n_born_agents: jax.Array
@@ -494,6 +493,7 @@ def set_agent_loc_fn(self, agent_loc_fn: str | tuple | LocatingFn) -> None:
 
     def step(
         self,
+        key: chex.PRNGKey,
         state: CFState,
         action: ArrayLike,
     ) -> tuple[CFState, TimeStep[CFObs]]:
@@ -550,15 +550,19 @@ def step(
         )
         return state.replace(physics=stated, solver=solver), timestep
 
-    def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:
-        key, activate_key = jax.random.split(state.key)
+    def activate(
+        self,
+        key: chex.PRNGKey,
+        state: CFState,
+        parent_gen: jax.Array,
+    ) -> tuple[CFState, bool]:
         (index,) = jnp.nonzero(
             jnp.logical_not(state.profile.is_active()),
             size=1,
             fill_value=-1,
         )
         index = index[0]
-        xy = self._place_agent(key=activate_key, stated=state.physics)
+        xy = self._place_agent(key=key, stated=state.physics)
         ok = jnp.logical_and(index >= 0, jnp.all(xy < jnp.inf))
 
         def success(state: CFState) -> tuple[CFState, bool]:
@@ -582,10 +586,7 @@ def success(state: CFState) -> tuple[CFState, bool]:
             )
             return new_state, True
 
-        def failure(state: CFState) -> tuple[CFState, bool]:
-            return state.replace(key=key), False
-
-        return jax.lax.cond(ok, success, failure)
+        return jax.lax.cond(ok, success, lambda: (state, False))
 
     def deactivate(self, state: CFState, index: Index) -> tuple[CFState, bool]:
         ok = state.profile.is_active()[index]
@@ -605,8 +606,7 @@ def success(state: CFState) -> tuple[CFState, bool]:
         return jax.lax.cond(ok, success, lambda state: (state, False))
 
     def reset(self, key: chex.PRNGKey) -> CFState:
-        state_key, init_key = jax.random.split(key)
-        physics, agent_loc, food_loc = self._initialize_physics_state(init_key)
+        physics, agent_loc, food_loc = self._initialize_physics_state(key)
         return CFState(  # type: ignore
             physics=physics,
             solver=self._physics.init_solver(),
@@ -614,7 +614,6 @@ def reset(self, key: chex.PRNGKey) -> CFState:
             food_loc=food_loc,
             food_num=self._initial_foodnum_state,
             # Protocols
-            key=state_key,
             step=jnp.array(0, dtype=jnp.int32),
             profile=init_profile(self._n_initial_agents, self._n_max_agents),
             n_born_agents=jnp.array(self._n_initial_agents, dtype=jnp.int32),
@@ -695,21 +694,23 @@ def _remove_and_reproduce_foods(
         food_num: FoodNumState,
         food_loc: LocatingState,
     ) -> tuple[StateDict, FoodNumState, LocatingState]:
-        def remove_food(eaten: jax.Array, sd: StateDict) -> StateDict:
+        def remove_food() -> StateDict:
             xy = jnp.where(
                 jnp.expand_dims(eaten, axis=1),
-                sd.static_circle.p.xy,
                 jnp.ones_like(sd.static_circle.p.xy) * NOWHERE,
+                sd.static_circle.p.xy,
             )
             is_active = jnp.logical_and(
                 sd.static_circle.is_active,
                 jnp.logical_not(eaten),
             )
+            p = sd.static_circle.p.replace(xy=xy)
+            static_circle = sd.static_circle.replace(p=p, is_active=is_active)
             sd = sd.nested_replace("static_circle.p.xy", xy)
             return sd.nested_replace("static_circle.is_active", is_active)
 
         n_eaten = jnp.sum(eaten)
-        sd = jax.lax.cond(n_eaten > 0, remove_food, lambda _, sd: sd, eaten, sd)
+        sd = jax.lax.cond(n_eaten > 0, remove_food, lambda _, sd: sd)
         food_num = self._food_num_fn(food_num.eaten(n_eaten))
 
         def try_place_food() -> tuple[StateDict, FoodNumState, LocatingState]:
@@ -723,8 +724,7 @@ def try_place_food() -> tuple[StateDict, FoodNumState, LocatingState]:
 
             def success(xy: jax.Array) -> tuple[StateDict, FoodNumState, LocatingState]:
                 xy = sd.static_circle.p.xy.at[index].set(xy)
-                angle = sd.static_circle.p.angle.at[index].set(0.0)
-                p = Position(angle=angle, xy=xy)
+                p = sd.static_circle.p.replace(xy=xy)
                 is_active = sd.static_circle.is_active.at[index].set(True)
                 static_circle = sd.static_circle.replace(p=p, is_active=is_active)
                 return (
@@ -733,11 +733,8 @@ def success(xy: jax.Array) -> tuple[StateDict, FoodNumState, LocatingState]:
                     food_loc.increment(),
                 )
 
-            def failure(xy: jax.Array) -> tuple[StateDict, FoodNumState, LocatingState]:
-                return sd, food_num, food_loc
-
             ok = jnp.logical_and(index >= 0, jnp.all(xy < jnp.inf))
-            return jax.lax.cond(ok, success, failure, xy)
+            return jax.lax.cond(ok, success, lambda _: (sd, food_num, food_loc), xy)
 
         return jax.lax.cond(
             food_num.appears(),

From fd676935216dabe852f4181049c170c2a49ec62f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 9 Nov 2023 14:41:51 +0900
Subject: [PATCH 068/337] Refactor foods

---
 smoke-tests/circle_loop.py                | 30 +++++++++
 src/emevo/env.py                          |  8 +--
 src/emevo/environments/circle_foraging.py | 81 +++++++++--------------
 src/emevo/environments/env_utils.py       |  4 +-
 4 files changed, 66 insertions(+), 57 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index b1989ce7..63746695 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -57,6 +57,36 @@ def main(
     else:
         visualizer = None
 
+    activate_index = n_agents
+    jit_step = jax.jit(env.step)
+    jit_sample = jax.jit(env.act_space.sample)
+    elapsed_list = []
+    for i in tqdm(range(steps)):
+        before = datetime.datetime.now()
+        state, _ = jit_step(state, jit_sample(keys[i + 1]))
+        elapsed = datetime.datetime.now() - before
+        if i == 0:
+            print(f"Compile: {elapsed.total_seconds()}s")
+        elif i > 10:
+            elapsed_list.append(elapsed / datetime.timedelta(microseconds=1))
+        if replace and i % 1000 == 0:
+            if n_agents + 5 <= activate_index:
+                state, success = env.deactivate(state, activate_index)
+                if not success:
+                    print(f"Failed to deactivate agent! {activate_index}")
+                else:
+                    activate_index -= 1
+            else:
+                state, success = env.activate(state, 0)
+                if not success:
+                    print("Failed to activate agent!")
+                else:
+                    activate_index += 1
+
+        if visualizer is not None:
+            visualizer.render(state)
+            visualizer.show()
+
     print(f"Avg. μs for step: {np.mean(elapsed_list)}")
 
 
diff --git a/src/emevo/env.py b/src/emevo/env.py
index 38d985c7..2eeb1409 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -68,6 +68,7 @@ def init_profile(n: int, max_n: int) -> Profile:
 
 
 class StateProtocol(Protocol):
+    key: chex.PRNGKey
     step: jax.Array
     profile: Profile
     n_born_agents: jax.Array
@@ -120,12 +121,7 @@ def step(self, state: STATE, action: ArrayLike) -> tuple[STATE, TimeStep[OBS]]:
         pass
 
     @abc.abstractmethod
-    def activate(
-        self,
-        key: chex.PRNGKey,
-        state: STATE,
-        parent_gen: int | jax.Array,
-    ) -> tuple[STATE, bool]:
+    def activate(self, state: STATE, parent_gen: int | jax.Array) -> tuple[STATE, bool]:
         """
         Mark an agent or some agents active.
         This method fails if there isn't enough space, returning (STATE, False).
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 6b4c3d98..ea048c04 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -81,6 +81,7 @@ class CFState:
     food_num: FoodNumState
     agent_loc: LocatingState
     food_loc: LocatingState
+    key: chex.PRNGKey
     step: jax.Array
     profile: Profile
     n_born_agents: jax.Array
@@ -493,7 +494,6 @@ def set_agent_loc_fn(self, agent_loc_fn: str | tuple | LocatingFn) -> None:
 
     def step(
         self,
-        key: chex.PRNGKey,
         state: CFState,
         action: ArrayLike,
     ) -> tuple[CFState, TimeStep[CFObs]]:
@@ -542,20 +542,15 @@ def step(
             state.food_loc,
         )
         state = state.replace(
+            key=key,
             physics=stated,
             solver=solver,
             food_num=food_num,
             food_loc=food_loc,
-            key=key,
         )
-        return state.replace(physics=stated, solver=solver), timestep
+        return state, timestep
 
-    def activate(
-        self,
-        key: chex.PRNGKey,
-        state: CFState,
-        parent_gen: jax.Array,
-    ) -> tuple[CFState, bool]:
+    def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:
         (index,) = jnp.nonzero(
             jnp.logical_not(state.profile.is_active()),
             size=1,
@@ -614,6 +609,7 @@ def reset(self, key: chex.PRNGKey) -> CFState:
             food_loc=food_loc,
             food_num=self._initial_foodnum_state,
             # Protocols
+            key=key,
             step=jnp.array(0, dtype=jnp.int32),
             profile=init_profile(self._n_initial_agents, self._n_max_agents),
             n_born_agents=jnp.array(self._n_initial_agents, dtype=jnp.int32),
@@ -694,53 +690,40 @@ def _remove_and_reproduce_foods(
         food_num: FoodNumState,
         food_loc: LocatingState,
     ) -> tuple[StateDict, FoodNumState, LocatingState]:
-        def remove_food() -> StateDict:
-            xy = jnp.where(
-                jnp.expand_dims(eaten, axis=1),
-                jnp.ones_like(sd.static_circle.p.xy) * NOWHERE,
-                sd.static_circle.p.xy,
-            )
-            is_active = jnp.logical_and(
-                sd.static_circle.is_active,
-                jnp.logical_not(eaten),
-            )
-            p = sd.static_circle.p.replace(xy=xy)
-            static_circle = sd.static_circle.replace(p=p, is_active=is_active)
-            sd = sd.nested_replace("static_circle.p.xy", xy)
-            return sd.nested_replace("static_circle.is_active", is_active)
-
-        n_eaten = jnp.sum(eaten)
-        sd = jax.lax.cond(n_eaten > 0, remove_food, lambda _, sd: sd)
-        food_num = self._food_num_fn(food_num.eaten(n_eaten))
-
-        def try_place_food() -> tuple[StateDict, FoodNumState, LocatingState]:
-            (index,) = jnp.nonzero(
-                jnp.logical_not(sd.static_circle.is_active),
-                size=1,
-                fill_value=-1,
-            )
+        xy = jnp.where(
+            jnp.expand_dims(eaten, axis=1),
+            jnp.ones_like(sd.static_circle.p.xy) * NOWHERE,
+            sd.static_circle.p.xy,
+        )
+        is_active = jnp.logical_and(sd.static_circle.is_active, jnp.logical_not(eaten))
+        p = sd.static_circle.p.replace(xy=xy)
+        sc = sd.static_circle.replace(p=p, is_active=is_active)
+        food_num = self._food_num_fn(food_num.eaten(jnp.sum(eaten)))
+
+        def dont_place(sc: State) -> tuple[State, int]:
+            return sc, 0
+
+        def try_place(sc: State) -> tuple[State, int]:
+            (index,) = jnp.nonzero(jnp.logical_not(sc.is_active), size=1, fill_value=-1)
             index = index[0]
             xy = self._place_food(loc_state=food_loc, key=key, stated=sd)
 
-            def success(xy: jax.Array) -> tuple[StateDict, FoodNumState, LocatingState]:
-                xy = sd.static_circle.p.xy.at[index].set(xy)
-                p = sd.static_circle.p.replace(xy=xy)
-                is_active = sd.static_circle.is_active.at[index].set(True)
-                static_circle = sd.static_circle.replace(p=p, is_active=is_active)
-                return (
-                    sd.replace(static_circle=static_circle),
-                    food_num.recover(1),
-                    food_loc.increment(),
-                )
+            def success(sc: State) -> tuple[State, int]:
+                p = sc.p.replace(xy=sc.p.xy.at[index].set(xy))
+                is_active = sc.is_active.at[index].set(True)
+                return sc.replace(p=p, is_active=is_active), 1
 
-            ok = jnp.logical_and(index >= 0, jnp.all(xy < jnp.inf))
-            return jax.lax.cond(ok, success, lambda _: (sd, food_num, food_loc), xy)
+            ok = jnp.logical_and(index >= 0, jnp.any(xy < jnp.inf))
+            return jax.lax.cond(ok, success, dont_place, sc)
 
-        return jax.lax.cond(
+        sc, incr = jax.lax.cond(
             food_num.appears(),
-            try_place_food,
-            lambda: (sd, food_num, food_loc),
+            try_place,
+            dont_place,
+            sc,
         )
+        sd = sd.replace(static_circle=sc)
+        return sd, food_num.recover(incr), food_loc.increment(incr)
 
     def visualizer(
         self,
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index 6da6b104..3497cbd4 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -169,8 +169,8 @@ def uniform(self, key: chex.PRNGKey) -> jax.Array:
 class LocatingState:
     n_produced: jax.Array
 
-    def increment(self) -> Self:
-        return self.replace(n_produced=self.n_produced + 1)
+    def increment(self, n: int = 1) -> Self:
+        return self.replace(n_produced=self.n_produced + n)
 
 
 LocatingFn = Callable[[chex.PRNGKey, LocatingState], jax.Array]

From 770d110df0c83050501d077a0746eecb8667c9b5 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 10 Nov 2023 16:28:25 +0900
Subject: [PATCH 069/337] Finally speed up food placing

---
 smoke-tests/circle_loop.py                |  1 +
 src/emevo/environments/circle_foraging.py | 46 +++++++++--------------
 src/emevo/environments/env_utils.py       | 15 ++++----
 tests/test_placement.py                   |  8 ++--
 4 files changed, 30 insertions(+), 40 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index 63746695..128b78f2 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -59,6 +59,7 @@ def main(
 
     activate_index = n_agents
     jit_step = jax.jit(env.step)
+    # jit_step = env.step
     jit_sample = jax.jit(env.act_space.sample)
     elapsed_list = []
     for i in tqdm(range(steps)):
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index ea048c04..d2c972d2 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -21,6 +21,7 @@
     ReprNum,
     ReprNumFn,
     SquareCoordinate,
+    first_true,
     place,
 )
 from emevo.environments.phyjax2d import Circle, Position, Raycast, ShapeDict
@@ -650,8 +651,8 @@ def _initialize_physics_state(
         agent_failed = 0
         agentloc_state = self._initial_foodloc_state
         for i, key in enumerate(keys[: self._n_initial_agents]):
-            xy = self._place_agent(loc_state=agentloc_state, key=key, stated=stated)
-            if jnp.all(xy < jnp.inf):
+            xy, ok = self._place_agent(loc_state=agentloc_state, key=key, stated=stated)
+            if ok:
                 stated = stated.nested_replace(
                     "circle.p.xy",
                     stated.circle.p.xy.at[i].set(xy),
@@ -666,8 +667,8 @@ def _initialize_physics_state(
         food_failed = 0
         foodloc_state = self._initial_foodloc_state
         for i, key in enumerate(keys[self._n_initial_agents :]):
-            xy = self._place_food(loc_state=foodloc_state, key=key, stated=stated)
-            if jnp.all(xy < jnp.inf):
+            xy, ok = self._place_food(loc_state=foodloc_state, key=key, stated=stated)
+            if ok:
                 stated = stated.nested_replace(
                     "static_circle.p.xy",
                     stated.static_circle.p.xy.at[i].set(xy),
@@ -690,39 +691,28 @@ def _remove_and_reproduce_foods(
         food_num: FoodNumState,
         food_loc: LocatingState,
     ) -> tuple[StateDict, FoodNumState, LocatingState]:
+        # Remove foods
         xy = jnp.where(
             jnp.expand_dims(eaten, axis=1),
             jnp.ones_like(sd.static_circle.p.xy) * NOWHERE,
             sd.static_circle.p.xy,
         )
         is_active = jnp.logical_and(sd.static_circle.is_active, jnp.logical_not(eaten))
-        p = sd.static_circle.p.replace(xy=xy)
-        sc = sd.static_circle.replace(p=p, is_active=is_active)
         food_num = self._food_num_fn(food_num.eaten(jnp.sum(eaten)))
-
-        def dont_place(sc: State) -> tuple[State, int]:
-            return sc, 0
-
-        def try_place(sc: State) -> tuple[State, int]:
-            (index,) = jnp.nonzero(jnp.logical_not(sc.is_active), size=1, fill_value=-1)
-            index = index[0]
-            xy = self._place_food(loc_state=food_loc, key=key, stated=sd)
-
-            def success(sc: State) -> tuple[State, int]:
-                p = sc.p.replace(xy=sc.p.xy.at[index].set(xy))
-                is_active = sc.is_active.at[index].set(True)
-                return sc.replace(p=p, is_active=is_active), 1
-
-            ok = jnp.logical_and(index >= 0, jnp.any(xy < jnp.inf))
-            return jax.lax.cond(ok, success, dont_place, sc)
-
-        sc, incr = jax.lax.cond(
-            food_num.appears(),
-            try_place,
-            dont_place,
-            sc,
+        # Generate new foods
+        first_inactive = first_true(jnp.logical_not(is_active))
+        new_food, ok = self._place_food(loc_state=food_loc, key=key, stated=sd)
+        place = jnp.logical_and(jnp.logical_and(ok, food_num.appears()), first_inactive)
+        xy = jnp.where(
+            jnp.expand_dims(place, axis=1),
+            jnp.expand_dims(new_food, axis=0),
+            xy,
         )
+        is_active = jnp.logical_or(is_active, place)
+        p = sd.static_circle.p.replace(xy=xy)
+        sc = sd.static_circle.replace(p=p, is_active=is_active)
         sd = sd.replace(static_circle=sc)
+        incr = jnp.sum(place)
         return sd, food_num.recover(incr), food_loc.increment(incr)
 
     def visualizer(
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index 3497cbd4..dbdab624 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -265,6 +265,10 @@ def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
 _vmap_co = jax.vmap(circle_overwrap, in_axes=(None, None, 0, None))
 
 
+def first_true(boolean_array: jax.Array) -> jax.Array:
+    return jnp.logical_and(boolean_array, jnp.cumsum(boolean_array) == 1)
+
+
 def place(
     n_trial: int,
     radius: float,
@@ -274,7 +278,7 @@ def place(
     key: chex.PRNGKey,
     shaped: ShapeDict,
     stated: StateDict,
-) -> jax.Array:
+) -> tuple[jax.Array, bool]:
     """Returns `[inf, inf]` if it fails"""
     keys = jax.random.split(key, n_trial)
     vmap_loc_fn = jax.vmap(loc_fn, in_axes=(0, None))
@@ -284,10 +288,5 @@ def place(
         contains_fn(locations, radius),
         jnp.logical_not(_vmap_co(shaped, stated, locations, radius)),
     )
-    (ok_idx,) = jnp.nonzero(ok, size=1, fill_value=-1)
-    ok_idx = ok_idx[0]
-    return jax.lax.cond(
-        ok_idx < 0,
-        lambda: jnp.ones(2) * jnp.inf,
-        lambda: locations[ok_idx],
-    )
+    mask = jnp.expand_dims(first_true(ok), axis=1)
+    return jnp.sum(mask * locations, axis=0), jnp.any(ok)
diff --git a/tests/test_placement.py b/tests/test_placement.py
index 8fe0922d..9a75c8dc 100644
--- a/tests/test_placement.py
+++ b/tests/test_placement.py
@@ -39,7 +39,7 @@ def test_place_agents(key) -> None:
     initloc_fn, initloc_state = Locating.UNIFORM(CircleCoordinate((100.0, 100.0), 95.0))
     assert stated.circle is not None
     for i, key in enumerate(keys):
-        xy = place(
+        xy, ok = place(
             n_trial=10,
             radius=AGENT_RADIUS,
             coordinate=coordinate,
@@ -49,7 +49,7 @@ def test_place_agents(key) -> None:
             shaped=space.shaped,
             stated=stated,
         )
-        assert jnp.all(xy < jnp.inf), stated.circle.p.xy
+        assert ok, stated.circle.p.xy
         stated = stated.nested_replace("circle.p.xy", stated.circle.p.xy.at[i].set(xy))
 
     is_active = jnp.concatenate(
@@ -72,7 +72,7 @@ def test_place_foods(key) -> None:
     reprloc_fn, reprloc_state = Locating.UNIFORM(CircleCoordinate((100.0, 100.0), 95.0))
     assert stated.static_circle is not None
     for i, key in enumerate(keys):
-        xy = place(
+        xy, ok = place(
             n_trial=10,
             radius=FOOD_RADIUS,
             coordinate=coordinate,
@@ -82,7 +82,7 @@ def test_place_foods(key) -> None:
             shaped=space.shaped,
             stated=stated,
         )
-        assert jnp.all(xy < jnp.inf), stated.circle.p.xy
+        assert ok, stated.circle.p.xy
         stated = stated.nested_replace(
             "static_circle.p.xy",
             stated.static_circle.p.xy.at[i].set(xy),

From 0dea20527b5b5994fefcf5aebb284e061d564f3a Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 10 Nov 2023 16:56:37 +0900
Subject: [PATCH 070/337] Reefactior activate/deactivate

---
 src/emevo/environments/circle_foraging.py | 83 ++++++++++-------------
 1 file changed, 36 insertions(+), 47 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index d2c972d2..225fb8fa 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -552,54 +552,43 @@ def step(
         return state, timestep
 
     def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:
-        (index,) = jnp.nonzero(
-            jnp.logical_not(state.profile.is_active()),
-            size=1,
-            fill_value=-1,
+        circle = state.physics.circle
+        new_xy, ok = self._place_agent(key=key, stated=state.physics)
+        place = jnp.logical_or(first_true(jnp.logical_not(circle.is_active)), ok)
+        xy = jnp.where(
+            jnp.expand_dims(place, axis=1),
+            jnp.expand_dims(new_xy, axis=0),
+            circle.p.xy,
         )
-        index = index[0]
-        xy = self._place_agent(key=key, stated=state.physics)
-        ok = jnp.logical_and(index >= 0, jnp.all(xy < jnp.inf))
-
-        def success(state: CFState) -> tuple[CFState, bool]:
-            circle_xy = state.physics.circle.p.xy.at[index].set(xy)
-            circle_angle = state.physics.circle.p.angle.at[index].set(0.0)
-            p = Position(angle=circle_angle, xy=circle_xy)
-            is_active = state.physics.circle.is_active.at[index].set(True)
-            circle = state.physics.circle.replace(p=p, is_active=is_active)
-            physics = state.physics.replace(circle=circle)
-            profile = state.profile.activate(
-                index,
-                parent_gen,
-                state.n_born_agents,
-                state.step,
-            )
-            new_state = state.replace(
-                physics=physics,
-                profile=profile,
-                n_born_agents=state.n_born_agents + 1,
-                key=key,
-            )
-            return new_state, True
-
-        return jax.lax.cond(ok, success, lambda: (state, False))
-
-    def deactivate(self, state: CFState, index: Index) -> tuple[CFState, bool]:
-        ok = state.profile.is_active()[index]
-
-        def success(state: CFState) -> tuple[CFState, bool]:
-            p_xy = state.physics.circle.p.xy.at[index].set(self._invisible_xy)
-            p = state.physics.circle.p.replace(xy=p_xy)
-            v_xy = state.physics.circle.v.xy.at[index].set(jnp.zeros(2))
-            v_angle = state.physics.circle.v.angle.at[index].set(0)
-            v = Velocity(angle=v_angle, xy=v_xy)
-            is_active = state.physics.circle.is_active.at[index].set(False)
-            circle = state.physics.circle.replace(p=p, v=v, is_active=is_active)
-            physics = state.physics.replace(circle=circle)
-            profile = state.profile.deactivate(index)
-            return state.replace(physics=physics, profile=profile), True
-
-        return jax.lax.cond(ok, success, lambda state: (state, False))
+        angle = jnp.where(place, 0.0, circle.p.angle)
+        p = Position(angle=angle, xy=xy)
+        is_active = jnp.logical_or(place, circle.is_active)
+        physics = state.physics.replace(circle=circle.replace(p=p, is_active=is_active))
+        profile = state.profile.activate(
+            index,
+            parent_gen,
+            state.n_born_agents,
+            state.step,
+        )
+        new_state = state.replace(
+            physics=physics,
+            profile=profile,
+            n_born_agents=state.n_born_agents + jnp.sum(place),
+            key=key,
+        )
+        return new_state, jnp.any(place)
+
+    def deactivate(self, state: CFState, index: Index) -> CFState:
+        p_xy = state.physics.circle.p.xy.at[index].set(self._invisible_xy)
+        p = state.physics.circle.p.replace(xy=p_xy)
+        v_xy = state.physics.circle.v.xy.at[index].set(jnp.zeros(2))
+        v_angle = state.physics.circle.v.angle.at[index].set(0)
+        v = Velocity(angle=v_angle, xy=v_xy)
+        is_active = state.physics.circle.is_active.at[index].set(False)
+        circle = state.physics.circle.replace(p=p, v=v, is_active=is_active)
+        physics = state.physics.replace(circle=circle)
+        profile = state.profile.deactivate(index)
+        return state.replace(physics=physics, profile=profile)
 
     def reset(self, key: chex.PRNGKey) -> CFState:
         physics, agent_loc, food_loc = self._initialize_physics_state(key)

From c1c73bc9f8d4e9f25555900a74986025dffbab40 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 10 Nov 2023 18:28:31 +0900
Subject: [PATCH 071/337] Refactor deactivate

---
 src/emevo/environments/circle_foraging.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 225fb8fa..4d7ecb91 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -581,8 +581,8 @@ def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool
     def deactivate(self, state: CFState, index: Index) -> CFState:
         p_xy = state.physics.circle.p.xy.at[index].set(self._invisible_xy)
         p = state.physics.circle.p.replace(xy=p_xy)
-        v_xy = state.physics.circle.v.xy.at[index].set(jnp.zeros(2))
-        v_angle = state.physics.circle.v.angle.at[index].set(0)
+        v_xy = state.physics.circle.v.xy.at[index].set(0.0)
+        v_angle = state.physics.circle.v.angle.at[index].set(0.0)
         v = Velocity(angle=v_angle, xy=v_xy)
         is_active = state.physics.circle.is_active.at[index].set(False)
         circle = state.physics.circle.replace(p=p, v=v, is_active=is_active)

From 257e6e67b2f0a2d53f2185cc8c40a260bb82b72f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Mon, 13 Nov 2023 10:10:51 +0900
Subject: [PATCH 072/337] Start implementing rollout

---
 smoke-tests/circle_ppo.py                 | 109 +++++++++++++---------
 src/emevo/environments/circle_foraging.py |   5 +-
 src/emevo/rl/ppo_normal.py                |  13 ++-
 3 files changed, 74 insertions(+), 53 deletions(-)

diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index 9359d8df..5a6ce2ee 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -4,22 +4,72 @@
 
 import jax
 import numpy as np
+import optax
+import qeuinox as eqx
 import typer
 from tqdm import tqdm
 
-from emevo import make, env:
-from emevo.rl.ppo import NormalPPONet
+from emevo import Env, make
+from emevo.env import ObsProtocol as Obs
+from emevo.env import StateProtocol as State
+from emevo.rl.ppo import NormalPPONet, Rollout, make_inormal
 
 
-def run_training(key: jax.Array, n_agents: int, env: Env) -> NormalPPONet:
+@eqx.filter_jit
+def exec_rollout(
+    state: State,
+    initial_obs: Obs,
+    env: Env,
+    network: NormalPPONet,
+    prng_key: jax.Array,
+    n_rollout_steps: int,
+) -> tuple[State, Rollout, State, jax.Array]:
+    def step_rollout(
+        carried: tuple[State, Obs],
+        key: jax.Array,
+    ) -> tuple[tuple[State, jax.Array], Rollout]:
+        state_t, obs_t = carried
+        obs_t = obs_t.as_array()
+        net_out = jax.vmap(network)(obs_t)
+        actions = net_out.policy().sample(seed=key)
+        state_t1, timestep = jax.vmap(env.step)(state_t, actions)
+        rollout = Rollout(
+            observations=obs_t,
+            actions=actions,
+            rewards=timestep.reward,
+            terminations=1.0 - timestep.discount,
+            values=net_out.value,
+            means=net_out.mean,
+            logstds=net_out.logstd,
+        )
+        return (state_t1, timestep.observation), rollout
+
+    (state, obs), rollout = jax.lax.scan(
+        step_rollout,
+        (state, initial_obs),
+        jax.random.split(prng_key, n_rollout_steps),
+    )
+    next_value = jax.vmap(network.value)(obs.as_array())
+    return state, rollout, obs, next_value
+
+
+def run_training(
+    key: jax.Array,
+    n_agents: int,
+    env: Env,
+    adam: optax.GradientTransformation,
+    n_total_steps: int,
+    n_rollout_steps: int,
+) -> NormalPPONet:
+    assert n_agents == 1
     key, net_key, reset_key = jax.random.split(key, 3)
     pponet = jax.vmap(NormalPPONet)(jax.random.split(net_key, n_agents))
-    adam_init, adam_update = optax.adam(adam_lr, eps=adam_eps)
+    adam_init, adam_update = adam
     opt_state = adam_init(eqx.filter(pponet, eqx.is_array))
-    env_state, timestep = env.reset()
+    env_state, timestep = env.reset(reset_key)
     obs = timestep.observation
 
-    n_loop = n_total_steps // (n_agents * n_rollout_steps)
+    n_loop = n_total_steps // n_rollout_steps
     return_reporting_interval = 1 if n_loop < 10 else n_loop // 10
     n_episodes, reward_sum = 0.0, 0.0
     for i in range(n_loop):
@@ -70,6 +120,7 @@ def main(
     n_total_steps: int = 16 * 512 * 100,
     ppo_clip_eps: float = 0.2,
     food_loc_fn: str = "gaussian",
+    env_shape: str = "circle",
 ) -> None:
     env = make(
         "CircleForaging-v0",
@@ -81,46 +132,12 @@ def main(
         foodloc_interval=20,
         obstacles=obstacles,
     )
-    key = jax.random.PRNGKey(seed)
-    keys = jax.random.split(key, steps + 1)
-    state = env.reset(keys[0])
-
-    if render:
-        visualizer = env.visualizer(state)
-    else:
-        visualizer = None
-
-    activate_index = n_agents
-    jit_step = jax.jit(env.step)
-    jit_sample = jax.jit(env.act_space.sample)
-    elapsed_list = []
-    for i, key in tqdm(zip(range(steps), keys[1:])):
-        before = datetime.datetime.now()
-        state, _ = jit_step(state, jit_sample(key))
-        elapsed = datetime.datetime.now() - before
-        if i == 0:
-            print(f"Compile: {elapsed.total_seconds()}s")
-        elif i > 10:
-            elapsed_list.append(elapsed / datetime.timedelta(microseconds=1))
-        if replace and i % 1000 == 0:
-            if n_agents + 5 <= activate_index:
-                state, success = env.deactivate(state, activate_index)
-                if not success:
-                    print(f"Failed to deactivate agent! {activate_index}")
-                else:
-                    activate_index -= 1
-            else:
-                state, success = env.activate(state, 0)
-                if not success:
-                    print("Failed to activate agent!")
-                else:
-                    activate_index += 1
-
-        if visualizer is not None:
-            visualizer.render(state)
-            visualizer.show()
-
-    print(f"Avg. μs for step: {np.mean(elapsed_list)}")
+    network = run_training(
+        jax.random.PRNGKey(seed),
+        n_agents,
+        env,
+        optax.adam(adam_lr, eps=adam_eps),
+    )
 
 
 if __name__ == "__main__":
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 4d7ecb91..db483537 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -553,7 +553,8 @@ def step(
 
     def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:
         circle = state.physics.circle
-        new_xy, ok = self._place_agent(key=key, stated=state.physics)
+        key, place_key = jax.random.split(state.key)
+        new_xy, ok = self._place_agent(key=place_key, stated=state.physics)
         place = jnp.logical_or(first_true(jnp.logical_not(circle.is_active)), ok)
         xy = jnp.where(
             jnp.expand_dims(place, axis=1),
@@ -565,7 +566,7 @@ def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool
         is_active = jnp.logical_or(place, circle.is_active)
         physics = state.physics.replace(circle=circle.replace(p=p, is_active=is_active))
         profile = state.profile.activate(
-            index,
+            place,
             parent_gen,
             state.n_born_agents,
             state.step,
diff --git a/src/emevo/rl/ppo_normal.py b/src/emevo/rl/ppo_normal.py
index 1c3aeca9..1cf6af05 100644
--- a/src/emevo/rl/ppo_normal.py
+++ b/src/emevo/rl/ppo_normal.py
@@ -11,11 +11,19 @@
 from jax.nn.initializers import orthogonal
 
 
+def make_inormal(mean: jax.Array, logstd: jax.Array) -> distrax.Distribution:
+    normal = distrax.LogStddevNormal(loc=mean, log_scale=logstd)
+    return distrax.Independent(normal, reinterpreted_batch_ndims=1)
+
+
 class Output(NamedTuple):
     mean: jax.Array
     logstd: jax.Array
     value: jax.Array
 
+    def policy(self) -> distrax.Distribution:
+        return make_inormal(self.mean, self.logstd)
+
 
 class NormalPPONet(eqx.Module):
     torso: list[eqx.Module]
@@ -118,11 +126,6 @@ def update(i: int, advantage_t: jax.Array) -> jax.Array:
     return advantage_t[:-1]
 
 
-def make_inormal(mean: jax.Array, logstd: jax.Array) -> distrax.Distribution:
-    normal = distrax.LogStddevNormal(loc=mean, log_scale=logstd)
-    return distrax.Independent(normal, reinterpreted_batch_ndims=1)
-
-
 def make_batch(
     rollout: Rollout,
     next_value: jax.Array,

From ed4a42b4d248747e679b2bcafc8cedea4e5edd92 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 13 Nov 2023 20:31:45 +0900
Subject: [PATCH 073/337] Make PPO work

---
 smoke-tests/circle_loop.py                |  9 ++-
 smoke-tests/circle_ppo.py                 | 88 +++++++++++++++--------
 src/emevo/__init__.py                     |  2 +-
 src/emevo/env.py                          |  2 +-
 src/emevo/environments/circle_foraging.py | 41 ++++++-----
 src/emevo/environments/phyjax2d.py        |  9 +--
 src/emevo/rl/ppo_normal.py                | 26 ++++++-
 src/emevo/spaces.py                       |  8 +--
 tests/test_observe.py                     | 31 ++++----
 tests/test_ppo.py                         | 40 +++++++++++
 10 files changed, 181 insertions(+), 75 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index 128b78f2..9cbadb3b 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -37,10 +37,11 @@ def main(
     else:
         additional_kwargs = {}
 
+    n_max_agents = n_agents + 10
     env = make(
         "CircleForaging-v0",
         env_shape=env_shape,
-        n_max_agents=n_agents + 10,
+        n_max_agents=n_max_agents,
         n_initial_agents=n_agents,
         food_num_fn=("constant", n_foods),
         food_loc_fn=food_loc_fn,
@@ -50,7 +51,7 @@ def main(
     )
     key = jax.random.PRNGKey(seed)
     keys = jax.random.split(key, steps + 1)
-    state = env.reset(keys[0])
+    state, _ = env.reset(keys[0])
 
     if render:
         visualizer = env.visualizer(state)
@@ -60,7 +61,9 @@ def main(
     activate_index = n_agents
     jit_step = jax.jit(env.step)
     # jit_step = env.step
-    jit_sample = jax.jit(env.act_space.sample)
+    jit_sample = jax.jit(
+        lambda key: jax.vmap(env.act_space.sample)(jax.random.split(key, n_max_agents))
+    )
     elapsed_list = []
     for i in tqdm(range(steps)):
         before = datetime.datetime.now()
diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index 5a6ce2ee..1a10795b 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -2,17 +2,29 @@
 
 import datetime
 
+import equinox as eqx
 import jax
+import jax.numpy as jnp
 import numpy as np
 import optax
-import qeuinox as eqx
 import typer
 from tqdm import tqdm
 
 from emevo import Env, make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
-from emevo.rl.ppo import NormalPPONet, Rollout, make_inormal
+from emevo.rl.ppo_normal import (
+    NormalPPONet,
+    Rollout,
+    make_inormal,
+    vmap_apply,
+    vmap_batch,
+    vmap_net,
+    vmap_update,
+    vmap_value,
+)
+
+N_MAX_AGENTS: int = 10
 
 
 @eqx.filter_jit
@@ -27,29 +39,30 @@ def exec_rollout(
     def step_rollout(
         carried: tuple[State, Obs],
         key: jax.Array,
-    ) -> tuple[tuple[State, jax.Array], Rollout]:
+    ) -> tuple[tuple[State, Obs], Rollout]:
         state_t, obs_t = carried
-        obs_t = obs_t.as_array()
-        net_out = jax.vmap(network)(obs_t)
+        obs_t_array = obs_t.as_array()
+        net_out = vmap_apply(network, obs_t_array)
         actions = net_out.policy().sample(seed=key)
-        state_t1, timestep = jax.vmap(env.step)(state_t, actions)
+        state_t1, timestep = env.step(state_t, actions)
+        rewards = obs_t.collision[:, 1]
         rollout = Rollout(
-            observations=obs_t,
+            observations=obs_t_array,
             actions=actions,
-            rewards=timestep.reward,
-            terminations=1.0 - timestep.discount,
+            rewards=rewards,
+            terminations=jnp.zeros_like(rewards),
             values=net_out.value,
             means=net_out.mean,
             logstds=net_out.logstd,
         )
-        return (state_t1, timestep.observation), rollout
+        return (state_t1, timestep.obs), rollout
 
     (state, obs), rollout = jax.lax.scan(
         step_rollout,
         (state, initial_obs),
         jax.random.split(prng_key, n_rollout_steps),
     )
-    next_value = jax.vmap(network.value)(obs.as_array())
+    next_value = vmap_value(network, obs.as_array()).ravel()
     return state, rollout, obs, next_value
 
 
@@ -58,20 +71,32 @@ def run_training(
     n_agents: int,
     env: Env,
     adam: optax.GradientTransformation,
-    n_total_steps: int,
+    gamma: float,
+    gae_lambda: float,
+    n_optim_epochs: int,
+    minibatch_size: int,
     n_rollout_steps: int,
+    n_total_steps: int,
+    ppo_clip_eps: float,
 ) -> NormalPPONet:
-    assert n_agents == 1
     key, net_key, reset_key = jax.random.split(key, 3)
-    pponet = jax.vmap(NormalPPONet)(jax.random.split(net_key, n_agents))
+    obs_space = env.obs_space.flatten()
+    input_size = np.prod(obs_space.shape)
+    act_size = np.prod(env.act_space.shape)
+    pponet = vmap_net(
+        input_size,
+        64,
+        act_size,
+        jax.random.split(net_key, N_MAX_AGENTS),
+    )
     adam_init, adam_update = adam
-    opt_state = adam_init(eqx.filter(pponet, eqx.is_array))
+    opt_state = jax.vmap(adam_init)(eqx.filter(pponet, eqx.is_array))
     env_state, timestep = env.reset(reset_key)
-    obs = timestep.observation
+    obs = timestep.obs
 
     n_loop = n_total_steps // n_rollout_steps
     return_reporting_interval = 1 if n_loop < 10 else n_loop // 10
-    n_episodes, reward_sum = 0.0, 0.0
+    rewards = jnp.zeros(N_MAX_AGENTS)
     for i in range(n_loop):
         key, rollout_key, update_key = jax.random.split(key, 3)
         env_state, rollout, obs, next_value = exec_rollout(
@@ -82,34 +107,29 @@ def run_training(
             rollout_key,
             n_rollout_steps,
         )
-        batch = make_batch(rollout, next_value, gamma, gae_lambda)
-        opt_state, pponet = update_network(
+        batch = jax.jit(vmap_batch)(rollout, next_value, gamma, gae_lambda)
+        opt_state, pponet = eqx.filter_jit(vmap_update)(
             batch,
             pponet,
             adam_update,
             opt_state,
-            update_key,
+            jax.random.split(update_key, N_MAX_AGENTS),
             minibatch_size,
             n_optim_epochs,
             ppo_clip_eps,
+            0.01,
         )
-        n_episodes += jnp.sum(rollout.terminations).item()
-        reward_sum += jnp.sum(rollout.rewards).item()
-        if i > 0 and (i % return_reporting_interval == 0):
-            print(f"Mean episodic return: {reward_sum / n_episodes}")
-            n_episodes = 0.0
-            reward_sum = 0.0
+        rewards += rollout.rewards
+    print(f"Sum of rewards {rewards}")
     return pponet
 
 
 def main(
-    steps: int = 100,
     seed: int = 1,
-    n_agents: int = 10,
+    n_agents: int = 2,
     n_foods: int = 10,
     obstacles: str = "none",
     render: bool = False,
-    replace: bool = False,
     adam_lr: float = 3e-4,
     adam_eps: float = 1e-7,
     gamma: float = 0.99,
@@ -122,10 +142,11 @@ def main(
     food_loc_fn: str = "gaussian",
     env_shape: str = "circle",
 ) -> None:
+    assert n_agents < N_MAX_AGENTS
     env = make(
         "CircleForaging-v0",
         env_shape=env_shape,
-        n_max_agents=n_agents + 1,
+        n_max_agents=N_MAX_AGENTS,
         n_initial_agents=n_agents,
         food_num_fn=("constant", n_foods),
         food_loc_fn=food_loc_fn,
@@ -137,6 +158,13 @@ def main(
         n_agents,
         env,
         optax.adam(adam_lr, eps=adam_eps),
+        gamma,
+        gae_lambda,
+        n_optim_epochs,
+        minibatch_size,
+        n_rollout_steps,
+        n_total_steps,
+        ppo_clip_eps,
     )
 
 
diff --git a/src/emevo/__init__.py b/src/emevo/__init__.py
index 5b563918..fc5c3ae8 100644
--- a/src/emevo/__init__.py
+++ b/src/emevo/__init__.py
@@ -4,7 +4,7 @@
 """
 
 
-from emevo.env import Profile, Env
+from emevo.env import Profile, Env, TimeStep
 from emevo.environments import make, register
 from emevo.status import Status
 from emevo.vec2d import Vec2d
diff --git a/src/emevo/env.py b/src/emevo/env.py
index 2eeb1409..7830f9ac 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -108,7 +108,7 @@ def __init__(self, *args, **kwargs) -> None:
         pass
 
     @abc.abstractmethod
-    def reset(self, key: chex.PRNGKey) -> STATE:
+    def reset(self, key: chex.PRNGKey) -> tuple[STATE, TimeStep[OBS]]:
         """Initialize environmental state."""
         pass
 
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index db483537..46d98a29 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -51,6 +51,7 @@
 AGENT_COLOR: Color = Color(2, 204, 254)
 FOOD_COLOR: Color = Color(254, 2, 162)
 NOWHERE: float = -100.0
+N_OBJECTS: int = 3
 
 
 class CFObs(NamedTuple):
@@ -66,10 +67,10 @@ def as_array(self) -> jax.Array:
         return jnp.concatenate(
             (
                 self.sensor.reshape(self.sensor.shape[0], -1),
-                self.collision.ravel(),
+                self.collision,
                 self.velocity,
-                self.angle,
-                self.angular_velocity,
+                jnp.expand_dims(self.angle, axis=1),
+                jnp.expand_dims(self.angular_velocity, axis=1),
             ),
             axis=1,
         )
@@ -368,15 +369,14 @@ def __init__(
         self._food_indices = jnp.arange(n_max_foods)
         self._n_physics_iter = n_physics_iter
         # Spaces
-        N = self._n_max_agents
-        self.act_space = BoxSpace(low=0.0, high=MAX_FORCE, shape=(N, 2))
+        self.act_space = BoxSpace(low=0.0, high=MAX_FORCE, shape=(2,))
         self.obs_space = NamedTupleSpace(
             CFObs,
-            sensor=BoxSpace(low=0.0, high=1.0, shape=(N, n_agent_sensors, 3)),
-            collision=BoxSpace(low=0.0, high=1.0, shape=(N, 3)),
-            velocity=BoxSpace(low=-MAX_VELOCITY, high=MAX_VELOCITY, shape=(N, 2)),
-            angle=BoxSpace(low=-2 * np.pi, high=2 * np.pi, shape=(N,)),
-            angular_velocity=BoxSpace(low=-np.pi / 10, high=np.pi / 10, shape=(N,)),
+            sensor=BoxSpace(low=0.0, high=1.0, shape=(n_agent_sensors, N_OBJECTS)),
+            collision=BoxSpace(low=0.0, high=1.0, shape=(N_OBJECTS,)),
+            velocity=BoxSpace(low=-MAX_VELOCITY, high=MAX_VELOCITY, shape=(2,)),
+            angle=BoxSpace(low=-2 * np.pi, high=2 * np.pi, shape=()),
+            angular_velocity=BoxSpace(low=-np.pi / 10, high=np.pi / 10, shape=()),
         )
         # Obs
         self._n_sensors = n_agent_sensors
@@ -384,9 +384,8 @@ def __init__(
         self._invisible_xy = jnp.ones(2) * NOWHERE
         act_p1 = Vec2d(0, agent_radius).rotated(np.pi * 0.75)
         act_p2 = Vec2d(0, agent_radius).rotated(-np.pi * 0.75)
-        N = self._n_max_agents
-        self._act_p1 = jnp.tile(jnp.array(act_p1), (N, 1))
-        self._act_p2 = jnp.tile(jnp.array(act_p2), (N, 1))
+        self._act_p1 = jnp.tile(jnp.array(act_p1), (self._n_max_agents, 1))
+        self._act_p2 = jnp.tile(jnp.array(act_p2), (self._n_max_agents, 1))
         self._place_agent = jax.jit(
             functools.partial(
                 place,
@@ -499,7 +498,7 @@ def step(
         action: ArrayLike,
     ) -> tuple[CFState, TimeStep[CFObs]]:
         # Add force
-        act = self.act_space.clip(jnp.array(action))
+        act = jax.vmap(self.act_space.clip)(jnp.array(action))
         f1, f2 = act[:, 0], act[:, 1]
         f1 = jnp.stack((jnp.zeros_like(f1), f1), axis=1) * -self._act_p1
         f2 = jnp.stack((jnp.zeros_like(f2), f2), axis=1) * -self._act_p2
@@ -591,9 +590,9 @@ def deactivate(self, state: CFState, index: Index) -> CFState:
         profile = state.profile.deactivate(index)
         return state.replace(physics=physics, profile=profile)
 
-    def reset(self, key: chex.PRNGKey) -> CFState:
+    def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
         physics, agent_loc, food_loc = self._initialize_physics_state(key)
-        return CFState(  # type: ignore
+        state = CFState(  # type: ignore
             physics=physics,
             solver=self._physics.init_solver(),
             agent_loc=agent_loc,
@@ -605,6 +604,16 @@ def reset(self, key: chex.PRNGKey) -> CFState:
             profile=init_profile(self._n_initial_agents, self._n_max_agents),
             n_born_agents=jnp.array(self._n_initial_agents, dtype=jnp.int32),
         )
+        sensor_obs = self._sensor_obs(stated=physics)
+        obs = CFObs(
+            sensor=sensor_obs.reshape(-1, self._n_sensors, N_OBJECTS),
+            collision=jnp.zeros((self._n_max_agents, N_OBJECTS), dtype=bool),
+            angle=physics.circle.p.angle,
+            velocity=physics.circle.v.xy,
+            angular_velocity=physics.circle.v.angle,
+        )
+        timestep = TimeStep(encount=None, obs=obs)
+        return state, timestep
 
     def _initialize_physics_state(
         self,
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 6ea35408..98158144 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -716,13 +716,14 @@ def init_solver(self) -> VelocitySolver:
 def update_velocity(space: Space, shape: Shape, state: State) -> State:
     # Expand (N, ) to (N, 1) because xy has a shape (N, 2)
     invm = jnp.expand_dims(shape.inv_mass(), axis=1)
-    gravity = jnp.where(
+    f_xy = jnp.where(
         jnp.logical_and(invm > 0, jnp.expand_dims(state.is_active, axis=1)),
-        space.gravity * jnp.ones_like(state.v.xy),
+        space.gravity * jnp.ones_like(state.v.xy) + state.f.xy * invm,
         jnp.zeros_like(state.v.xy),
     )
-    v_xy = state.v.xy + (gravity + state.f.xy * invm) * space.dt
-    v_ang = state.v.angle + state.f.angle * shape.inv_moment() * space.dt
+    v_xy = state.v.xy + f_xy * space.dt
+    f_ang = jnp.where(state.is_active, state.f.angle, 0.0)
+    v_ang = state.v.angle + f_ang * shape.inv_moment() * space.dt
     v_xy = jnp.clip(
         v_xy * space.linear_damping,
         a_max=space.max_velocity,
diff --git a/src/emevo/rl/ppo_normal.py b/src/emevo/rl/ppo_normal.py
index 1cf6af05..1cf4a518 100644
--- a/src/emevo/rl/ppo_normal.py
+++ b/src/emevo/rl/ppo_normal.py
@@ -67,7 +67,7 @@ def __call__(self, x: jax.Array) -> Output:
     def value(self, x: jax.Array) -> jax.Array:
         for layer in self.torso:
             x = layer(x)
-        return self.value(x)
+        return self.value_head(x)
 
 
 @chex.dataclass
@@ -137,7 +137,7 @@ def make_batch(
         rollout.rewards,
         # Set γ = 0 when the episode terminates
         (1.0 - rollout.terminations) * gamma,
-        all_values,
+        all_values.ravel(),
         gae_lambda,
     )
     value_targets = advantages + all_values[:-1]
@@ -240,3 +240,25 @@ def update_once(
         minibatches,
     )
     return opt_state, eqx.combine(updated_dynet, static_net)
+
+
+# Convenient functions for model ensemble
+
+
+@eqx.filter_vmap(in_axes=(eqx.if_array(0), 0))
+def vmap_apply(net: NormalPPONet, obs: jax.Array) -> jax.Array:
+    return net(obs)
+
+
+@eqx.filter_vmap(in_axes=(eqx.if_array(0), 0))
+def vmap_value(net: NormalPPONet, obs: jax.Array) -> jax.Array:
+    return net.value(obs)
+
+
+vmap_net = eqx.filter_vmap(NormalPPONet, in_axes=(None, None, None, 0))
+# Suppose that rollout has (N_steps, N_models, ...) shape
+vmap_batch = jax.vmap(make_batch, in_axes=(1, 0, None, None))
+vmap_update = eqx.filter_vmap(
+    update_network,
+    in_axes=(0, eqx.if_array(0), None, 0, 0, None, None, None, None),
+)
diff --git a/src/emevo/spaces.py b/src/emevo/spaces.py
index 516ba76f..07a29025 100644
--- a/src/emevo/spaces.py
+++ b/src/emevo/spaces.py
@@ -15,7 +15,7 @@
 
 
 class Space(abc.ABC, Generic[INSTANCE]):
-    dtype: jnp.dtype
+    dtype: jnp.dtype | tuple[jnp.dtype, ...]
     shape: tuple[int, ...]
 
     @abc.abstractmethod
@@ -263,11 +263,7 @@ def __init__(self, cls: type[tuple], **spaces_kwargs: Space) -> None:
             tuple((field, spaces_kwargs[field].__class__) for field in fields),
         )
         self.spaces = self._space_cls(**spaces_kwargs)
-        dtype = self.spaces[0].dtype
-        for space in self.spaces:
-            if space.dtype != dtype:
-                raise ValueError("All dtype of NamedTuple space must be the same")
-        self.dtype = dtype
+        self.dtype = tuple(s.dtype for s in self.spaces)
         self.shape = tuple(space.shape for space in self.spaces)
 
     def clip(self, x: tuple) -> Any:
diff --git a/tests/test_observe.py b/tests/test_observe.py
index 3263d0fe..b335aa35 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -3,11 +3,10 @@
 import jax.numpy as jnp
 import pytest
 
-from emevo import Env, make
-from emevo.environments.circle_foraging import CFState, _observe_closest, get_sensor_obs
+from emevo import Env, make, TimeStep
+from emevo.environments.circle_foraging import CFState, _observe_closest, get_sensor_obs, CFObs
 
-N_MAX_AGENTS = 20
-N_MAX_FOODS = 10
+N_MAX_AGENTS = 10
 AGENT_RADIUS = 10
 FOOD_RADIUS = 4
 
@@ -17,14 +16,14 @@ def key() -> chex.PRNGKey:
     return jax.random.PRNGKey(43)
 
 
-def reset_env(key: chex.PRNGKey) -> tuple[Env, CFState]:
+def reset_env(key: chex.PRNGKey) -> tuple[Env, CFState, TimeStep[CFObs]]:
     #     x
     #   O x O
     # O x O  O  (O: agent, x: food)
     env = make(
         "CircleForaging-v0",
         env_shape="square",
-        n_max_agents=10,
+        n_max_agents=N_MAX_AGENTS,
         n_initial_agents=5,
         agent_loc_fn=(
             "periodic",
@@ -42,14 +41,15 @@ def reset_env(key: chex.PRNGKey) -> tuple[Env, CFState]:
         ),
         food_num_fn=("constant", 3),
         foodloc_interval=20,
-        agent_radius=10,
-        food_radius=4,
+        agent_radius=AGENT_RADIUS,
+        food_radius=FOOD_RADIUS,
     )
-    return env, env.reset(key)
+    state, timestep = env.reset(key)
+    return env, state, timestep
 
 
 def test_observe_closest(key: chex.PRNGKey) -> None:
-    env, state = reset_env(key)
+    env, state, _ = reset_env(key)
     obs = _observe_closest(
         env._physics.shaped,
         jnp.array([40.0, 10.0]),
@@ -81,7 +81,7 @@ def test_observe_closest(key: chex.PRNGKey) -> None:
 
 
 def test_sensor_obs(key: chex.PRNGKey) -> None:
-    env, state = reset_env(key)
+    env, state, _ = reset_env(key)
     sensor_obs = get_sensor_obs(
         env._physics.shaped,
         3,
@@ -125,7 +125,7 @@ def test_sensor_obs(key: chex.PRNGKey) -> None:
 
 
 def test_encount(key: chex.PRNGKey) -> None:
-    env, state = reset_env(key)
+    env, state, _ = reset_env(key)
     act1 = jnp.zeros((10, 2)).at[4, 1].set(1.0).at[2, 0].set(1.0)
     step = jax.jit(env.step)
     while True:
@@ -144,3 +144,10 @@ def test_encount(key: chex.PRNGKey) -> None:
         else:
             assert jnp.all(jnp.logical_not(ts.encount)), f"P1: {p1}, P2: {p2}"
     assert i < 999
+
+
+def test_asarray(key: chex.PRNGKey) -> None:
+    env, state, timestep = reset_env(key)
+    obs = timestep.obs.as_array()
+    obs_shape = env.obs_space.flatten().shape[0]
+    chex.assert_shape(obs, (N_MAX_AGENTS, obs_shape))
diff --git a/tests/test_ppo.py b/tests/test_ppo.py
index bb6b0da1..1478b4cf 100644
--- a/tests/test_ppo.py
+++ b/tests/test_ppo.py
@@ -6,11 +6,15 @@
 import pytest
 
 from emevo.rl.ppo_normal import (
+    Batch,
     NormalPPONet,
     Rollout,
     get_minibatches,
     make_batch,
     update_network,
+    vmap_batch,
+    vmap_net,
+    vmap_update,
 )
 
 OBS_SIZE = 10
@@ -83,3 +87,39 @@ def test_update_network(key: chex.PRNGKey) -> None:
     before, _ = eqx.partition(pponet, eqx.is_array)
     after, _ = eqx.partition(updated, eqx.is_array)
     chex.assert_trees_all_equal_shapes(before, after)
+
+
+def test_ensemble(key: chex.PRNGKey) -> None:
+    n = 3
+    rollouts = jax.tree_map(
+        lambda *args: jnp.stack(args, axis=1),
+        *[_rollout() for _ in range(n)],
+    )
+    batch = vmap_batch(rollouts, jnp.zeros((n,)), 0.99, 0.95)
+    chex.assert_shape(batch.observations, (n, STEP_SIZE, OBS_SIZE))
+
+    key, net_key = jax.random.split(key)
+    pponet = vmap_net(OBS_SIZE, 5, ACT_SIZE, jax.random.split(net_key, n))
+    out = eqx.filter_vmap(lambda net, obs: jax.vmap(net)(obs))(
+        pponet,
+        batch.observations,
+    )
+    chex.assert_shape(out.mean, (n, STEP_SIZE, ACT_SIZE))
+
+    adam_init, adam_update = optax.adam(1e-3)
+    opt_state = jax.vmap(adam_init)(eqx.filter(pponet, eqx.is_array))
+
+    _, updated = vmap_update(
+        batch,
+        pponet,
+        adam_update,
+        opt_state,
+        jax.random.split(key, n),
+        64,
+        10,
+        0.1,
+        0.01,
+    )
+    before, _ = eqx.partition(pponet, eqx.is_array)
+    after, _ = eqx.partition(updated, eqx.is_array)
+    chex.assert_trees_all_equal_shapes(before, after)

From 8f1d9bd5445a6a0213ebeea9096771707caa13a4 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 14 Nov 2023 18:39:48 +0900
Subject: [PATCH 074/337] Make PPO work

---
 smoke-tests/circle_ppo.py | 151 +++++++++++++++++++++++++++++++-------
 src/emevo/__init__.py     |   1 +
 2 files changed, 124 insertions(+), 28 deletions(-)

diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index 1a10795b..f348b582 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -1,7 +1,9 @@
 """Example of using circle foraging environment"""
 
 import datetime
+from pathlib import Path
 
+import chex
 import equinox as eqx
 import jax
 import jax.numpy as jnp
@@ -10,7 +12,7 @@
 import typer
 from tqdm import tqdm
 
-from emevo import Env, make
+from emevo import Env, Visualizer, make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
 from emevo.rl.ppo_normal import (
@@ -27,7 +29,25 @@
 N_MAX_AGENTS: int = 10
 
 
-@eqx.filter_jit
+def visualize(key: chex.PRNGKey, env: Env, network: NormalPPONet, n_steps: int) -> None:
+    keys = jax.random.split(key, n_steps + 1)
+    state, ts = env.reset(keys[0])
+    obs = ts.obs
+    visualizer = env.visualizer(state, figsize=(640.0, 640.0))
+
+    @eqx.filter_jit
+    def step(key: chex.PRNGKey, state: State, obs: Obs) -> tuple[State, Obs]:
+        net_out = vmap_apply(network, obs.as_array())
+        actions = net_out.policy().sample(seed=key)
+        next_state, timestep = env.step(state, actions)
+        return next_state, timestep.obs
+
+    for key in keys[1:]:
+        state, obs = step(key, state, obs)
+        visualizer.render(state)
+        visualizer.show()
+
+
 def exec_rollout(
     state: State,
     initial_obs: Obs,
@@ -35,7 +55,7 @@ def exec_rollout(
     network: NormalPPONet,
     prng_key: jax.Array,
     n_rollout_steps: int,
-) -> tuple[State, Rollout, State, jax.Array]:
+) -> tuple[State, Rollout, Obs, jax.Array]:
     def step_rollout(
         carried: tuple[State, Obs],
         key: jax.Array,
@@ -45,7 +65,7 @@ def step_rollout(
         net_out = vmap_apply(network, obs_t_array)
         actions = net_out.policy().sample(seed=key)
         state_t1, timestep = env.step(state_t, actions)
-        rewards = obs_t.collision[:, 1]
+        rewards = obs_t.collision[:, 1].astype(jnp.float32)
         rollout = Rollout(
             observations=obs_t_array,
             actions=actions,
@@ -66,6 +86,45 @@ def step_rollout(
     return state, rollout, obs, next_value
 
 
+@eqx.filter_jit
+def training_step(
+    state: State,
+    initial_obs: Obs,
+    env: Env,
+    network: NormalPPONet,
+    prng_key: jax.Array,
+    n_rollout_steps: int,
+    gamma: float,
+    gae_lambda: float,
+    adam_update: optax.TransformUpdateFn,
+    opt_state: optax.OptState,
+    minibatch_size: int,
+    n_optim_epochs: int,
+) -> tuple[State, Obs, jax.Array, optax.OptState, NormalPPONet]:
+    keys = jax.random.split(prng_key, N_MAX_AGENTS + 1)
+    env_state, rollout, obs, next_value = exec_rollout(
+        state,
+        initial_obs,
+        env,
+        network,
+        keys[0],
+        n_rollout_steps,
+    )
+    batch = jax.jit(vmap_batch)(rollout, next_value, gamma, gae_lambda)
+    opt_state, pponet = vmap_update(
+        batch,
+        network,
+        adam_update,
+        opt_state,
+        keys[1:],
+        minibatch_size,
+        n_optim_epochs,
+        0.2,
+        0.01,
+    )
+    return env_state, obs, rollout.rewards, opt_state, pponet
+
+
 def run_training(
     key: jax.Array,
     n_agents: int,
@@ -77,7 +136,6 @@ def run_training(
     minibatch_size: int,
     n_rollout_steps: int,
     n_total_steps: int,
-    ppo_clip_eps: float,
 ) -> NormalPPONet:
     key, net_key, reset_key = jax.random.split(key, 3)
     obs_space = env.obs_space.flatten()
@@ -95,36 +153,35 @@ def run_training(
     obs = timestep.obs
 
     n_loop = n_total_steps // n_rollout_steps
-    return_reporting_interval = 1 if n_loop < 10 else n_loop // 10
     rewards = jnp.zeros(N_MAX_AGENTS)
-    for i in range(n_loop):
-        key, rollout_key, update_key = jax.random.split(key, 3)
-        env_state, rollout, obs, next_value = exec_rollout(
+    keys = jax.random.split(key, n_loop)
+    for key in keys:
+        env_state, obs, rewards_i, opt_state, pponet = training_step(
             env_state,
             obs,
             env,
             pponet,
-            rollout_key,
+            key,
             n_rollout_steps,
-        )
-        batch = jax.jit(vmap_batch)(rollout, next_value, gamma, gae_lambda)
-        opt_state, pponet = eqx.filter_jit(vmap_update)(
-            batch,
-            pponet,
+            gamma,
+            gae_lambda,
             adam_update,
             opt_state,
-            jax.random.split(update_key, N_MAX_AGENTS),
             minibatch_size,
             n_optim_epochs,
-            ppo_clip_eps,
-            0.01,
         )
-        rewards += rollout.rewards
-    print(f"Sum of rewards {rewards}")
+        ri = jnp.sum(rewards_i, axis=0)
+        rewards = rewards + ri
+        print(f"Rewards: {[x.item() for x in ri[: n_agents]]}")
+    print(f"Sum of rewards {[x.item() for x in rewards[: n_agents]]}")
     return pponet
 
 
-def main(
+app = typer.Typer(pretty_exceptions_show_locals=False)
+
+
+@app.command()
+def train(
     seed: int = 1,
     n_agents: int = 2,
     n_foods: int = 10,
@@ -135,12 +192,11 @@ def main(
     gamma: float = 0.99,
     gae_lambda: float = 0.95,
     n_optim_epochs: int = 10,
-    minibatch_size: int = 1024,
+    minibatch_size: int = 128,
     n_rollout_steps: int = 512,
-    n_total_steps: int = 16 * 512 * 100,
-    ppo_clip_eps: float = 0.2,
+    n_total_steps: int = 512 * 100,
     food_loc_fn: str = "gaussian",
-    env_shape: str = "circle",
+    env_shape: str = "square",
 ) -> None:
     assert n_agents < N_MAX_AGENTS
     env = make(
@@ -153,8 +209,9 @@ def main(
         foodloc_interval=20,
         obstacles=obstacles,
     )
+    train_key, eval_key = jax.random.split(jax.random.PRNGKey(seed))
     network = run_training(
-        jax.random.PRNGKey(seed),
+        train_key,
         n_agents,
         env,
         optax.adam(adam_lr, eps=adam_eps),
@@ -164,9 +221,47 @@ def main(
         minibatch_size,
         n_rollout_steps,
         n_total_steps,
-        ppo_clip_eps,
     )
+    if render:
+        visualize(eval_key, env, network, 1000)
+    eqx.tree_serialise_leaves("trained.eqx", network)
+
+
+@app.command()
+def vis(
+    modelpath: Path = Path("trained.eqx"),
+    n_steps: int = 1000,
+    seed: int = 1,
+    n_agents: int = 2,
+    n_foods: int = 10,
+    food_loc_fn: str = "gaussian",
+    env_shape: str = "square",
+    obstacles: str = "none",
+) -> None:
+    assert n_agents < N_MAX_AGENTS
+    env = make(
+        "CircleForaging-v0",
+        env_shape=env_shape,
+        n_max_agents=N_MAX_AGENTS,
+        n_initial_agents=n_agents,
+        food_num_fn=("constant", n_foods),
+        food_loc_fn=food_loc_fn,
+        foodloc_interval=20,
+        obstacles=obstacles,
+    )
+    obs_space = env.obs_space.flatten()
+    input_size = np.prod(obs_space.shape)
+    act_size = np.prod(env.act_space.shape)
+    net_key, eval_key = jax.random.split(jax.random.PRNGKey(seed))
+    pponet = vmap_net(
+        input_size,
+        64,
+        act_size,
+        jax.random.split(net_key, N_MAX_AGENTS),
+    )
+    pponet = eqx.tree_deserialise_leaves(modelpath, pponet)
+    visualize(eval_key, env, pponet, n_steps)
 
 
 if __name__ == "__main__":
-    typer.run(main)
+    app()
diff --git a/src/emevo/__init__.py b/src/emevo/__init__.py
index fc5c3ae8..1065910c 100644
--- a/src/emevo/__init__.py
+++ b/src/emevo/__init__.py
@@ -8,6 +8,7 @@
 from emevo.environments import make, register
 from emevo.status import Status
 from emevo.vec2d import Vec2d
+from emevo.visualizer import Visualizer
 
 
 __version__ = "0.1.0"

From b5dcad84988b89fecc00e9c97439fa8b1465e7f2 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 15 Nov 2023 17:12:41 +0900
Subject: [PATCH 075/337] Visualize sensors again

---
 smoke-tests/circle_ppo.py                 | 18 ++++++++++---
 src/emevo/environments/circle_foraging.py | 33 +++++++++++++++++++----
 src/emevo/environments/moderngl_vis.py    | 30 +++++++++++++++++++--
 3 files changed, 70 insertions(+), 11 deletions(-)

diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index f348b582..1d773379 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -2,6 +2,7 @@
 
 import datetime
 from pathlib import Path
+from typing import Optional
 
 import chex
 import equinox as eqx
@@ -18,22 +19,30 @@
 from emevo.rl.ppo_normal import (
     NormalPPONet,
     Rollout,
-    make_inormal,
     vmap_apply,
     vmap_batch,
     vmap_net,
     vmap_update,
     vmap_value,
 )
+from emevo.visualizer import SaveVideoWrapper
 
 N_MAX_AGENTS: int = 10
 
 
-def visualize(key: chex.PRNGKey, env: Env, network: NormalPPONet, n_steps: int) -> None:
+def visualize(
+    key: chex.PRNGKey,
+    env: Env,
+    network: NormalPPONet,
+    n_steps: int,
+    videoname: Path | None,
+) -> None:
     keys = jax.random.split(key, n_steps + 1)
     state, ts = env.reset(keys[0])
     obs = ts.obs
     visualizer = env.visualizer(state, figsize=(640.0, 640.0))
+    if videoname is not None:
+        visualizer = SaveVideoWrapper(visualizer, videoname, fps=60)
 
     @eqx.filter_jit
     def step(key: chex.PRNGKey, state: State, obs: Obs) -> tuple[State, Obs]:
@@ -223,7 +232,7 @@ def train(
         n_total_steps,
     )
     if render:
-        visualize(eval_key, env, network, 1000)
+        visualize(eval_key, env, network, 1000, videoname)
     eqx.tree_serialise_leaves("trained.eqx", network)
 
 
@@ -237,6 +246,7 @@ def vis(
     food_loc_fn: str = "gaussian",
     env_shape: str = "square",
     obstacles: str = "none",
+    videoname: Optional[str] = None,
 ) -> None:
     assert n_agents < N_MAX_AGENTS
     env = make(
@@ -260,7 +270,7 @@ def vis(
         jax.random.split(net_key, N_MAX_AGENTS),
     )
     pponet = eqx.tree_deserialise_leaves(modelpath, pponet)
-    visualize(eval_key, env, pponet, n_steps)
+    visualize(eval_key, env, pponet, n_steps, videoname)
 
 
 if __name__ == "__main__":
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 46d98a29..853d46a0 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -246,14 +246,13 @@ def cr(shape: Circle, state: State) -> Raycast:
 _vmap_obs = jax.vmap(_observe_closest, in_axes=(None, 0, 0, None))
 
 
-def get_sensor_obs(
+def _get_sensors(
     shaped: ShapeDict,
     n_sensors: int,
     sensor_range: tuple[float, float],
     sensor_length: float,
     stated: StateDict,
-) -> None:
-    assert stated.circle is not None
+) -> tuple[jax.Array, jax.Array]:
     radius = shaped.circle.radius
     p1 = jnp.stack((jnp.zeros_like(radius), radius), axis=1)  # (N, 2)
     p1 = jnp.repeat(p1, n_sensors, axis=0)  # (N x M, 2)
@@ -265,6 +264,18 @@ def get_sensor_obs(
     )
     p1 = sensor_p.transform(p1)
     p2 = sensor_p.transform(p2)
+    return p1, p2
+
+
+def get_sensor_obs(
+    shaped: ShapeDict,
+    n_sensors: int,
+    sensor_range: tuple[float, float],
+    sensor_length: float,
+    stated: StateDict,
+) -> jax.Array:
+    assert stated.circle is not None
+    p1, p2 = _get_sensors(shaped, n_sensors, sensor_range, sensor_length, stated)
     return _vmap_obs(shaped, p1, p2, stated)
 
 
@@ -300,8 +311,8 @@ def __init__(
         env_radius: float = 120.0,
         env_shape: Literal["square", "circle"] = "square",
         obstacles: list[tuple[Vec2d, Vec2d]] | str = "none",
-        n_agent_sensors: int = 8,
-        sensor_length: float = 10.0,
+        n_agent_sensors: int = 16,
+        sensor_length: float = 100.0,
         sensor_range: tuple[float, float] | SensorRange = SensorRange.WIDE,
         agent_radius: float = 10.0,
         food_radius: float = 4.0,
@@ -420,6 +431,17 @@ def __init__(
             )
         )
 
+        # For visualization
+        self._get_sensors = jax.jit(
+            functools.partial(
+                _get_sensors,
+                shaped=self._physics.shaped,
+                n_sensors=n_agent_sensors,
+                sensor_range=sensor_range_tuple,
+                sensor_length=sensor_length,
+            )
+        )
+
     @staticmethod
     def _make_food_num_fn(
         food_num_fn: str | tuple | ReprNumFn,
@@ -731,5 +753,6 @@ def visualizer(
             stated=state.physics,
             figsize=figsize,
             backend=mgl_backend,
+            sensor_fn=self._get_sensors,
             **kwargs,
         )
diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index 5e2a37ec..fc3d0429 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -4,7 +4,7 @@
 """
 from __future__ import annotations
 
-from typing import Any, ClassVar, Protocol
+from typing import Any, Callable, ClassVar, Protocol
 
 import moderngl as mgl
 import moderngl_window as mglw
@@ -267,7 +267,6 @@ def _collect_circles(
 
 
 def _collect_static_lines(segment: Segment, state: State) -> NDArray:
-    points = []
     a, b = segment.get_ab()
     a = state.p.transform(a)
     b = state.p.transform(b)
@@ -308,6 +307,7 @@ def __init__(
         stated: StateDict,
         voffsets: tuple[int, ...] = (),
         hoffsets: tuple[int, ...] = (),
+        sensor_fn: Callable[[StateDict], tuple[NDArray, NDArray]] | None = None,
     ) -> None:
         self._context = context
 
@@ -364,6 +364,27 @@ def __init__(
             program=static_segment_program,
             segments=_collect_static_lines(space.shaped.segment, stated.segment),
         )
+        if sensor_fn is not None:
+            segment_program = self._make_gl_program(
+                vertex_shader=_LINE_VERTEX_SHADER,
+                geometry_shader=_LINE_GEOMETRY_SHADER,
+                fragment_shader=_LINE_FRAGMENT_SHADER,
+                color=np.array([0.0, 0.0, 0.0, 0.2], dtype=np.float32),
+                width=np.array([0.002], dtype=np.float32),
+            )
+
+            def collect_sensors(stated: StateDict) -> NDArray:
+                return np.concatenate(sensor_fn(stated=stated), axis=1).reshape(-1, 2)
+
+            self._sensors = SegmentVA(
+                ctx=context,
+                program=segment_program,
+                segments=collect_sensors(stated),
+            )
+            self._collect_sensors = collect_sensors
+        else:
+            self._sensors, self._collect_sensors = None, None
+
         head_program = self._make_gl_program(
             vertex_shader=_LINE_VERTEX_SHADER,
             geometry_shader=_LINE_GEOMETRY_SHADER,
@@ -464,6 +485,9 @@ def render(self, stated: StateDict) -> None:
             self._circles.render()
         if self._static_circles.update(*static_circles):
             self._static_circles.render()
+        if self._sensors is not None and self._collect_sensors is not None:
+            if self._sensors.update(self._collect_sensors(stated)):
+                self._sensors.render()
         if self._heads.update(_collect_heads(self._space.shaped.circle, stated.circle)):
             self._heads.render()
         self._static_lines.render()
@@ -486,6 +510,7 @@ def __init__(
         hoffsets: tuple[int, ...] = (),
         vsync: bool = False,
         backend: str = "pyglet",
+        sensor_fn: Callable[[StateDict], tuple[NDArray, NDArray]] | None = None,
         title: str = "EmEvo CircleForaging",
     ) -> None:
         self.pix_fmt = "rgba"
@@ -511,6 +536,7 @@ def __init__(
             stated=stated,
             voffsets=voffsets,
             hoffsets=hoffsets,
+            sensor_fn=sensor_fn,
         )
 
     def close(self) -> None:

From dd1920ca3e0fe799e1eb873c890b1e23572b8e5b Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 16 Nov 2023 16:35:13 +0900
Subject: [PATCH 076/337] Tweak on action space

---
 smoke-tests/circle_loop.py                |  1 +
 src/emevo/environments/circle_foraging.py | 39 ++++++++++++-----------
 tests/test_placement.py                   |  4 +++
 3 files changed, 25 insertions(+), 19 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index 9cbadb3b..211ad9b2 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -73,6 +73,7 @@ def main(
             print(f"Compile: {elapsed.total_seconds()}s")
         elif i > 10:
             elapsed_list.append(elapsed / datetime.timedelta(microseconds=1))
+
         if replace and i % 1000 == 0:
             if n_agents + 5 <= activate_index:
                 state, success = env.deactivate(state, activate_index)
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 853d46a0..4f8fe861 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -47,7 +47,7 @@
 
 MAX_ANGULAR_VELOCITY: float = float(np.pi)
 MAX_VELOCITY: float = 10.0
-MAX_FORCE: float = 1.0
+MAX_FORCE: float = 20.0
 AGENT_COLOR: Color = Color(2, 204, 254)
 FOOD_COLOR: Color = Color(254, 2, 162)
 NOWHERE: float = -100.0
@@ -153,14 +153,14 @@ def _get_num_or_loc_fn(
 def _make_physics(
     dt: float,
     coordinate: CircleCoordinate | SquareCoordinate,
-    linear_damping: float = 0.9,
-    angular_damping: float = 0.9,
-    n_velocity_iter: int = 6,
-    n_position_iter: int = 2,
-    n_max_agents: int = 40,
-    n_max_foods: int = 20,
-    agent_radius: float = 10.0,
-    food_radius: float = 4.0,
+    linear_damping: float,
+    angular_damping: float,
+    n_velocity_iter: int,
+    n_position_iter: int,
+    n_max_agents: int,
+    n_max_foods: int,
+    agent_radius: float,
+    food_radius: float,
     obstacles: list[tuple[Vec2d, Vec2d]] | None = None,
 ) -> tuple[Physics, State]:
     builder = SpaceBuilder(
@@ -191,16 +191,16 @@ def _make_physics(
         xy = jnp.array(wall[0] + wall[1]) / 2
         position = Position(angle=angle, xy=xy)
         segments.append(position)
-        builder.add_segment(length=a2b.length, friction=0.1, elasticity=0.2)
+        builder.add_segment(length=a2b.length, friction=0.2, elasticity=0.4)
     seg_position = jax.tree_map(lambda *args: jnp.stack(args), *segments)
     seg_state = State.from_position(seg_position)
     # Prepare agents
     for _ in range(n_max_agents):
         builder.add_circle(
             radius=agent_radius,
-            friction=0.1,
-            elasticity=0.2,
-            density=0.04,
+            friction=0.2,
+            elasticity=0.4,
+            density=0.1,
             color=AGENT_COLOR,
         )
     # Prepare foods
@@ -318,11 +318,11 @@ def __init__(
         food_radius: float = 4.0,
         foodloc_interval: int = 1000,
         dt: float = 0.1,
-        linear_damping: float = 0.9,
-        angular_damping: float = 0.8,
+        linear_damping: float = 0.8,
+        angular_damping: float = 0.6,
         n_velocity_iter: int = 6,
         n_position_iter: int = 2,
-        n_physics_iter: int = 5,
+        n_physics_iter: int = 10,
         max_place_attempts: int = 10,
     ) -> None:
         # Coordinate and range
@@ -521,9 +521,10 @@ def step(
     ) -> tuple[CFState, TimeStep[CFObs]]:
         # Add force
         act = jax.vmap(self.act_space.clip)(jnp.array(action))
-        f1, f2 = act[:, 0], act[:, 1]
-        f1 = jnp.stack((jnp.zeros_like(f1), f1), axis=1) * -self._act_p1
-        f2 = jnp.stack((jnp.zeros_like(f2), f2), axis=1) * -self._act_p2
+        f1 = jax.lax.slice_in_dim(act, 0, 1, axis=-1)
+        f2 = jax.lax.slice_in_dim(act, 1, 2, axis=-1)
+        f1 = jnp.concatenate((jnp.zeros_like(f1), f1), axis=1)
+        f2 = jnp.concatenate((jnp.zeros_like(f2), f2), axis=1)
         circle = state.physics.circle
         circle = circle.apply_force_local(self._act_p1, f1)
         circle = circle.apply_force_local(self._act_p2, f2)
diff --git a/tests/test_placement.py b/tests/test_placement.py
index 9a75c8dc..eb8ccc4f 100644
--- a/tests/test_placement.py
+++ b/tests/test_placement.py
@@ -23,6 +23,10 @@ def get_space_and_more() -> tuple[Space, StateDict, CircleCoordinate]:
     space, seg_state = _make_physics(
         0.1,
         coordinate,
+        linear_damping=0.9,
+        angular_damping=0.9,
+        n_velocity_iter=4,
+        n_posiiton_iter=2,
         n_max_agents=N_MAX_AGENTS,
         n_max_foods=N_MAX_FOODS,
         agent_radius=AGENT_RADIUS,

From 774e1416f75d6ad94b775f2819fcab8d73f60797 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 16 Nov 2023 16:40:06 +0900
Subject: [PATCH 077/337] Add rl/__init__.py

---
 src/emevo/rl/__init__.py | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 src/emevo/rl/__init__.py

diff --git a/src/emevo/rl/__init__.py b/src/emevo/rl/__init__.py
new file mode 100644
index 00000000..d2943d5c
--- /dev/null
+++ b/src/emevo/rl/__init__.py
@@ -0,0 +1 @@
+"""Reinforcment learning tools for emevo"""

From daef4cb52b9eb9047d2669ca917b7c6de03d6960 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 16 Nov 2023 18:05:34 +0900
Subject: [PATCH 078/337] Sigmoid scaleing to action

---
 smoke-tests/circle_ppo.py |  4 ++--
 src/emevo/spaces.py       | 10 +++++++---
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index 1d773379..2c222f81 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -48,7 +48,7 @@ def visualize(
     def step(key: chex.PRNGKey, state: State, obs: Obs) -> tuple[State, Obs]:
         net_out = vmap_apply(network, obs.as_array())
         actions = net_out.policy().sample(seed=key)
-        next_state, timestep = env.step(state, actions)
+        next_state, timestep = env.step(state, env.act_space.sigmoid_scale(actions))
         return next_state, timestep.obs
 
     for key in keys[1:]:
@@ -73,7 +73,7 @@ def step_rollout(
         obs_t_array = obs_t.as_array()
         net_out = vmap_apply(network, obs_t_array)
         actions = net_out.policy().sample(seed=key)
-        state_t1, timestep = env.step(state_t, actions)
+        state_t1, timestep = env.step(state_t, env.act_space.sigmoid_scale(actions))
         rewards = obs_t.collision[:, 1].astype(jnp.float32)
         rollout = Rollout(
             observations=obs_t_array,
diff --git a/src/emevo/spaces.py b/src/emevo/spaces.py
index 07a29025..893ddade 100644
--- a/src/emevo/spaces.py
+++ b/src/emevo/spaces.py
@@ -14,6 +14,7 @@
 INSTANCE = TypeVar("INSTANCE")
 
 
+
 class Space(abc.ABC, Generic[INSTANCE]):
     dtype: jnp.dtype | tuple[jnp.dtype, ...]
     shape: tuple[int, ...]
@@ -83,6 +84,7 @@ def __init__(
 
         self.low = low.astype(self.dtype)
         self.high = high.astype(self.dtype)
+        self._range = self.high = self.low
 
         self.low_repr = _short_repr(self.low)
         self.high_repr = _short_repr(self.high)
@@ -140,9 +142,11 @@ def sample(self, key: chex.PRNGKey) -> jax.Array:
         else:
             return sample.astype(self.dtype)
 
-    def normalize(self, normalized: jax.Array) -> jax.Array:
-        range_ = self.high - self.low  # type: ignore
-        return (normalized - self.low) / range_  # type: ignore
+    def normalize(self, unnormalized: jax.Array) -> jax.Array:
+        return (unnormalized - self.low) / self._range
+
+    def sigmoid_scale(self, array: jax.Array) -> jax.Array:
+        return self._range * jax.nn.sigmoid(array) + self.low
 
     def __repr__(self) -> str:
         return f"Box({self.low_repr}, {self.high_repr}, {self.shape}, {self.dtype})"

From 453172403cf0136d05b7fca603f80a56a842573d Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 17 Nov 2023 18:04:38 +0900
Subject: [PATCH 079/337] Tweak on action space, some more debug on PPO

---
 smoke-tests/circle_ppo.py                 | 25 ++++++++++++++++-------
 src/emevo/environments/circle_foraging.py | 24 +++++++++++++---------
 src/emevo/rl/ppo_normal.py                |  2 +-
 src/emevo/spaces.py                       |  2 +-
 tests/test_ppo.py                         | 10 +++++++++
 5 files changed, 44 insertions(+), 19 deletions(-)

diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index 2c222f81..09968567 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -44,15 +44,17 @@ def visualize(
     if videoname is not None:
         visualizer = SaveVideoWrapper(visualizer, videoname, fps=60)
 
+    # Returns action for debugging
     @eqx.filter_jit
-    def step(key: chex.PRNGKey, state: State, obs: Obs) -> tuple[State, Obs]:
+    def step(key: chex.PRNGKey, state: State, obs: Obs) -> tuple[State, Obs, jax.Array]:
         net_out = vmap_apply(network, obs.as_array())
         actions = net_out.policy().sample(seed=key)
         next_state, timestep = env.step(state, env.act_space.sigmoid_scale(actions))
-        return next_state, timestep.obs
+        return next_state, timestep.obs, actions
 
     for key in keys[1:]:
-        state, obs = step(key, state, obs)
+        state, obs, act = step(key, state, obs)
+        print(f"Act: {act[0]}")
         visualizer.render(state)
         visualizer.show()
 
@@ -74,7 +76,7 @@ def step_rollout(
         net_out = vmap_apply(network, obs_t_array)
         actions = net_out.policy().sample(seed=key)
         state_t1, timestep = env.step(state_t, env.act_space.sigmoid_scale(actions))
-        rewards = obs_t.collision[:, 1].astype(jnp.float32)
+        rewards = obs_t.collision[:, 1].astype(jnp.float32).reshape(-1, 1)
         rollout = Rollout(
             observations=obs_t_array,
             actions=actions,
@@ -91,7 +93,7 @@ def step_rollout(
         (state, initial_obs),
         jax.random.split(prng_key, n_rollout_steps),
     )
-    next_value = vmap_value(network, obs.as_array()).ravel()
+    next_value = vmap_value(network, obs.as_array())
     return state, rollout, obs, next_value
 
 
@@ -119,7 +121,8 @@ def training_step(
         keys[0],
         n_rollout_steps,
     )
-    batch = jax.jit(vmap_batch)(rollout, next_value, gamma, gae_lambda)
+    batch = vmap_batch(rollout, next_value, gamma, gae_lambda)
+    output = vmap_apply(network, obs.as_array())
     opt_state, pponet = vmap_update(
         batch,
         network,
@@ -179,7 +182,7 @@ def run_training(
             minibatch_size,
             n_optim_epochs,
         )
-        ri = jnp.sum(rewards_i, axis=0)
+        ri = jnp.sum(jnp.squeeze(rewards_i, axis=-1), axis=0)
         rewards = rewards + ri
         print(f"Rewards: {[x.item() for x in ri[: n_agents]]}")
     print(f"Sum of rewards {[x.item() for x in rewards[: n_agents]]}")
@@ -206,6 +209,8 @@ def train(
     n_total_steps: int = 512 * 100,
     food_loc_fn: str = "gaussian",
     env_shape: str = "square",
+    xlim: int = 200,
+    ylim: int = 200,
 ) -> None:
     assert n_agents < N_MAX_AGENTS
     env = make(
@@ -217,6 +222,8 @@ def train(
         food_loc_fn=food_loc_fn,
         foodloc_interval=20,
         obstacles=obstacles,
+        xlim=(0.0, float(xlim)),
+        ylim=(0.0, float(ylim)),
     )
     train_key, eval_key = jax.random.split(jax.random.PRNGKey(seed))
     network = run_training(
@@ -247,6 +254,8 @@ def vis(
     env_shape: str = "square",
     obstacles: str = "none",
     videoname: Optional[str] = None,
+    xlim: int = 200,
+    ylim: int = 200,
 ) -> None:
     assert n_agents < N_MAX_AGENTS
     env = make(
@@ -258,6 +267,8 @@ def vis(
         food_loc_fn=food_loc_fn,
         foodloc_interval=20,
         obstacles=obstacles,
+        xlim=(0.0, float(xlim)),
+        ylim=(0.0, float(ylim)),
     )
     obs_space = env.obs_space.flatten()
     input_size = np.prod(obs_space.shape)
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 4f8fe861..f6ce7444 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -47,7 +47,10 @@
 
 MAX_ANGULAR_VELOCITY: float = float(np.pi)
 MAX_VELOCITY: float = 10.0
-MAX_FORCE: float = 20.0
+MIN_ROT_FORCE: float = -10.0
+MAX_ROT_FORCE: float = 10.0
+MIN_PUSH_FORCE: float = -20.0
+MAX_PUSH_FORCE: float = 40.0
 AGENT_COLOR: Color = Color(2, 204, 254)
 FOOD_COLOR: Color = Color(254, 2, 162)
 NOWHERE: float = -100.0
@@ -380,7 +383,10 @@ def __init__(
         self._food_indices = jnp.arange(n_max_foods)
         self._n_physics_iter = n_physics_iter
         # Spaces
-        self.act_space = BoxSpace(low=0.0, high=MAX_FORCE, shape=(2,))
+        self.act_space = BoxSpace(
+            low=jnp.array([MIN_ROT_FORCE, MIN_PUSH_FORCE]),
+            high=jnp.array([MAX_ROT_FORCE, MAX_PUSH_FORCE]),
+        )
         self.obs_space = NamedTupleSpace(
             CFObs,
             sensor=BoxSpace(low=0.0, high=1.0, shape=(n_agent_sensors, N_OBJECTS)),
@@ -393,10 +399,8 @@ def __init__(
         self._n_sensors = n_agent_sensors
         # Some cached constants
         self._invisible_xy = jnp.ones(2) * NOWHERE
-        act_p1 = Vec2d(0, agent_radius).rotated(np.pi * 0.75)
-        act_p2 = Vec2d(0, agent_radius).rotated(-np.pi * 0.75)
-        self._act_p1 = jnp.tile(jnp.array(act_p1), (self._n_max_agents, 1))
-        self._act_p2 = jnp.tile(jnp.array(act_p2), (self._n_max_agents, 1))
+        self._rot_p = jnp.tile(jnp.array([0.0, agent_radius]), (self._n_max_agents, 1))
+        self._push_p = jnp.zeros((self._n_max_agents, 2))
         self._place_agent = jax.jit(
             functools.partial(
                 place,
@@ -523,11 +527,11 @@ def step(
         act = jax.vmap(self.act_space.clip)(jnp.array(action))
         f1 = jax.lax.slice_in_dim(act, 0, 1, axis=-1)
         f2 = jax.lax.slice_in_dim(act, 1, 2, axis=-1)
-        f1 = jnp.concatenate((jnp.zeros_like(f1), f1), axis=1)
-        f2 = jnp.concatenate((jnp.zeros_like(f2), f2), axis=1)
+        rot = jnp.concatenate((f1, jnp.zeros_like(f1)), axis=1)
+        push = jnp.concatenate((jnp.zeros_like(f2), f2), axis=1)
         circle = state.physics.circle
-        circle = circle.apply_force_local(self._act_p1, f1)
-        circle = circle.apply_force_local(self._act_p2, f2)
+        circle = circle.apply_force_local(self._rot_p, rot)
+        circle = circle.apply_force_local(self._push_p, push)
         stated = state.physics.replace(circle=circle)
         # Step physics simulator
         stated, solver, nstep_contacts = nstep(
diff --git a/src/emevo/rl/ppo_normal.py b/src/emevo/rl/ppo_normal.py
index 1cf4a518..cabcec82 100644
--- a/src/emevo/rl/ppo_normal.py
+++ b/src/emevo/rl/ppo_normal.py
@@ -137,7 +137,7 @@ def make_batch(
         rollout.rewards,
         # Set γ = 0 when the episode terminates
         (1.0 - rollout.terminations) * gamma,
-        all_values.ravel(),
+        all_values,
         gae_lambda,
     )
     value_targets = advantages + all_values[:-1]
diff --git a/src/emevo/spaces.py b/src/emevo/spaces.py
index 893ddade..0fe37e7c 100644
--- a/src/emevo/spaces.py
+++ b/src/emevo/spaces.py
@@ -84,7 +84,7 @@ def __init__(
 
         self.low = low.astype(self.dtype)
         self.high = high.astype(self.dtype)
-        self._range = self.high = self.low
+        self._range = self.high - self.low
 
         self.low_repr = _short_repr(self.low)
         self.high_repr = _short_repr(self.high)
diff --git a/tests/test_ppo.py b/tests/test_ppo.py
index 1478b4cf..b99b1e72 100644
--- a/tests/test_ppo.py
+++ b/tests/test_ppo.py
@@ -66,6 +66,16 @@ def test_minibatches(key: chex.PRNGKey) -> None:
     chex.assert_shape(minibatch.value_targets, (*prefix,))
 
 
+def test_output(key: chex.PRNGKey) -> None:
+    rollout = _rollout()
+    batch = make_batch(rollout, jnp.zeros((1,)), 0.99, 0.95)
+    pponet = NormalPPONet(OBS_SIZE, 5, ACT_SIZE, key)
+    output = jax.vmap(pponet)(batch.observations)
+    chex.assert_shape(output.value, (STEP_SIZE, 1))
+    chex.assert_shape(output.mean, (STEP_SIZE, ACT_SIZE))
+    chex.assert_shape(output.logstd, (STEP_SIZE, ACT_SIZE))
+
+
 def test_update_network(key: chex.PRNGKey) -> None:
     rollout = _rollout()
     batch = make_batch(rollout, jnp.zeros((1,)), 0.99, 0.95)

From 7087c4de4df89e11bd9cf080429c3c3f20cd7115 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 20 Nov 2023 17:48:13 +0900
Subject: [PATCH 080/337] Simpler way for collision obs

---
 smoke-tests/circle_ppo.py                 |  3 ++
 src/emevo/environments/circle_foraging.py | 24 ++++++++------
 src/emevo/environments/env_utils.py       | 16 +++++----
 src/emevo/environments/phyjax2d.py        | 24 ++------------
 tests/test_observe.py                     | 40 ++++++++++++++++++-----
 5 files changed, 59 insertions(+), 48 deletions(-)

diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index 09968567..d75def30 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -167,6 +167,7 @@ def run_training(
     n_loop = n_total_steps // n_rollout_steps
     rewards = jnp.zeros(N_MAX_AGENTS)
     keys = jax.random.split(key, n_loop)
+    visualizer = env.visualizer(env_state, figsize=(640.0, 640.0))
     for key in keys:
         env_state, obs, rewards_i, opt_state, pponet = training_step(
             env_state,
@@ -182,6 +183,8 @@ def run_training(
             minibatch_size,
             n_optim_epochs,
         )
+        visualizer.render(env_state)
+        visualizer.show()
         ri = jnp.sum(jnp.squeeze(rewards_i, axis=-1), axis=0)
         rewards = rewards + ri
         print(f"Rewards: {[x.item() for x in ri[: n_agents]]}")
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index f6ce7444..a58df1e4 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -542,28 +542,32 @@ def step(
         )
         # Gather circle contacts
         contacts = jnp.max(nstep_contacts, axis=0)
-        circle_contacts = self._physics.get_specific_contact("circle", contacts)
+        c2c = self._physics.get_contact_mat("circle", "circle", contacts)
+        c2sc = self._physics.get_contact_mat("circle", "static_circle", contacts)
+        seg2c = self._physics.get_contact_mat("segment", "circle", contacts)
+        collision = jnp.stack(
+            (jnp.max(c2c, axis=1), jnp.max(c2sc, axis=1), jnp.max(seg2c, axis=0)),
+            axis=1,
+        )
         # Gather sensor obs
         sensor_obs = self._sensor_obs(stated=stated)
         obs = CFObs(
             sensor=sensor_obs.reshape(-1, self._n_sensors, 3),
-            collision=circle_contacts,
+            collision=collision,
             angle=stated.circle.p.angle,
             velocity=stated.circle.v.xy,
             angular_velocity=stated.circle.v.angle,
         )
-        encount = self._physics.get_contact_mat("circle", "circle", contacts)
-        timestep = TimeStep(encount=encount, obs=obs)
-        # Remove and reproduce foods
-        food_contacts = self._physics.get_contact_mat(
-            "circle",
-            "static_circle",
-            contacts,
+        timestep = TimeStep(
+            encount=c2c,
+            obs=obs,
+            info={"contacts": contacts, "foods": jnp.max(c2sc, axis=0)},
         )
+        # Remove and reproduce foods
         key, food_key = jax.random.split(state.key)
         stated, food_num, food_loc = self._remove_and_reproduce_foods(
             food_key,
-            jnp.max(food_contacts, axis=0),
+            jnp.max(c2sc, axis=0),
             stated,
             state.food_num,
             state.food_loc,
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index dbdab624..77d12c48 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -43,10 +43,8 @@ class ReprNumConstant:
     initial: int
 
     def __call__(self, state: FoodNumState) -> FoodNumState:
-        internal = jnp.fmax(state.current, state.internal)
-        diff = jnp.clip(self.initial - state.current, a_min=0)
-        state = state.replace(internal=internal + diff)
-        return state
+        # Do nothing here
+        return state.replace(internal=self.initial)
 
 
 @dataclasses.dataclass(frozen=True)
@@ -168,9 +166,10 @@ def uniform(self, key: chex.PRNGKey) -> jax.Array:
 @chex.dataclass
 class LocatingState:
     n_produced: jax.Array
+    n_trial: jax.Array
 
     def increment(self, n: int = 1) -> Self:
-        return self.replace(n_produced=self.n_produced + n)
+        return self.replace(n_produced=self.n_produced + n, n_trial=self.n_trial + 1)
 
 
 LocatingFn = Callable[[chex.PRNGKey, LocatingState], jax.Array]
@@ -186,7 +185,10 @@ class Locating(str, enum.Enum):
     UNIFORM = "uniform"
 
     def __call__(self, *args: Any, **kwargs: Any) -> tuple[LocatingFn, LocatingState]:
-        state = LocatingState(n_produced=jnp.array(0, dtype=jnp.int32))
+        state = LocatingState(
+            n_produced=jnp.array(0, dtype=jnp.int32),
+            n_trial=jnp.array(0, dtype=jnp.int32),
+        )
         if self is Locating.GAUSSIAN:
             return loc_gaussian(*args, **kwargs), state
         elif self is Locating.GAUSSIAN_MIXTURE:
@@ -237,7 +239,7 @@ def __init__(self, *locations: ArrayLike) -> None:
         self._n = self._locations.shape[0]
 
     def __call__(self, _key: chex.PRNGKey, state: LocatingState) -> jax.Array:
-        return self._locations[state.n_produced % self._n]
+        return self._locations[state.n_trial % self._n]
 
 
 class LocSwitching:
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 98158144..c630fc02 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -669,36 +669,16 @@ def n_possible_contacts(self) -> int:
                     n += len1 * len2
         return n
 
-    def get_specific_contact(self, name: str, contact: jax.Array) -> jax.Array:
-        idx1, idx2 = self._ci_total.index1, self._ci_total.index2
-        offset = _offset(self.shaped, name)
-        size = self.shaped[name].batch_size()
-        n = self.shaped.n_shapes()
-        has_contact_list = []
-        for n1, n2 in _CONTACT_FUNCTIONS.keys():
-            contact_offset = self._contact_offset.get((n1, n2), None)
-            if contact_offset is not None:
-                has_contact = jnp.zeros(n, dtype=bool)
-                from_, to = contact_offset
-                cont = contact[from_:to]
-                if n1 == n2:
-                    has_contact = cont[idx1[from_:to]].at[idx2[from_:to]].max(cont)
-                elif n1 == name:
-                    has_contact = cont[idx1[from_:to]]
-                else:
-                    has_contact = cont[idx2[from_:to]]
-                has_contact_list.append(has_contact[offset : offset + size])
-        return jnp.stack(has_contact_list, axis=1)
-
     def get_contact_mat(self, n1: str, n2: str, contact: jax.Array) -> jax.Array:
         contact_offset = self._contact_offset.get((n1, n2), None)
         assert contact_offset is not None
         from_, to = contact_offset
         size1, size2 = self.shaped[n1].batch_size(), self.shaped[n2].batch_size()
+        cnt = contact[from_:to]
         if n1 == n2:
             ret = jnp.zeros((size1, size1), dtype=bool)
             idx1, idx2 = jnp.triu_indices(size1, k=1)
-            return ret.at[idx1, idx2].set(contact[from_:to])
+            return ret.at[idx1, idx2].set(cnt).at[idx2, idx1].set(cnt)
         else:
             return contact[from_:to].reshape(size1, size2)
 
diff --git a/tests/test_observe.py b/tests/test_observe.py
index b335aa35..e7eb871f 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -3,8 +3,13 @@
 import jax.numpy as jnp
 import pytest
 
-from emevo import Env, make, TimeStep
-from emevo.environments.circle_foraging import CFState, _observe_closest, get_sensor_obs, CFObs
+from emevo import Env, TimeStep, make
+from emevo.environments.circle_foraging import (
+    CFObs,
+    CFState,
+    _observe_closest,
+    get_sensor_obs,
+)
 
 N_MAX_AGENTS = 10
 AGENT_RADIUS = 10
@@ -124,26 +129,43 @@ def test_sensor_obs(key: chex.PRNGKey) -> None:
     )
 
 
-def test_encount(key: chex.PRNGKey) -> None:
+def test_encount_and_collision(key: chex.PRNGKey) -> None:
+    #     x
+    #   O x←3
+    # O x 2→ ←4
     env, state, _ = reset_env(key)
-    act1 = jnp.zeros((10, 2)).at[4, 1].set(1.0).at[2, 0].set(1.0)
     step = jax.jit(env.step)
+    act1 = jnp.zeros((10, 2)).at[2, 0].set(5.0).at[3, 0].set(-5.0).at[4, 0].set(-5.0)
     while True:
         state, ts = step(state, act1)
         assert jnp.all(jnp.logical_not(ts.encount))
-        if state.physics.circle.p.angle[4] >= jnp.pi * 0.5:
+        if state.physics.circle.p.angle[4] >= jnp.pi * 0.4:
+            break
+    act2 = jnp.zeros((10, 2)).at[2, 1].set(10.0).at[3, 1].set(10.0).at[4, 1].set(10.0)
+    for i in range(100):
+        state, ts = step(state, act2)
+        p = state.physics.circle.p.xy[3]
+        if jnp.linalg.norm(p - jnp.array([80.0, 90.0])) <= AGENT_RADIUS + FOOD_RADIUS:
+            assert bool(ts.obs.collision[3, 1]), p
             break
-    act2 = jnp.zeros((10, 2)).at[4].set(1.0).at[2].set(1.0)
-    for i in range(1000):
+        else:
+            assert not jnp.any(ts.obs.collision), ts.obs.collision[:5]
+
+    assert i < 99
+
+    for i in range(100):
         state, ts = step(state, act2)
         p1 = state.physics.circle.p.xy[2]
         p2 = state.physics.circle.p.xy[4]
-        if jnp.linalg.norm(p1 - p2) <= 20.0:
+        if jnp.linalg.norm(p1 - p2) <= 2 * AGENT_RADIUS:
             assert bool(ts.encount[2, 4])
+            assert bool(ts.encount[4, 2])
+            assert bool(ts.obs.collision[2, 0])
+            assert bool(ts.obs.collision[4, 0])
             break
         else:
             assert jnp.all(jnp.logical_not(ts.encount)), f"P1: {p1}, P2: {p2}"
-    assert i < 999
+    assert i < 99
 
 
 def test_asarray(key: chex.PRNGKey) -> None:

From 218488a5c90aaa8ecd33bea1c281d7508c1d12a6 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 20 Nov 2023 17:49:10 +0900
Subject: [PATCH 081/337] Fix test

---
 tests/test_observe.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/test_observe.py b/tests/test_observe.py
index e7eb871f..4aa424c2 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -153,7 +153,7 @@ def test_encount_and_collision(key: chex.PRNGKey) -> None:
 
     assert i < 99
 
-    for i in range(100):
+    for i in range(200):
         state, ts = step(state, act2)
         p1 = state.physics.circle.p.xy[2]
         p2 = state.physics.circle.p.xy[4]
@@ -165,7 +165,7 @@ def test_encount_and_collision(key: chex.PRNGKey) -> None:
             break
         else:
             assert jnp.all(jnp.logical_not(ts.encount)), f"P1: {p1}, P2: {p2}"
-    assert i < 99
+    assert i < 199
 
 
 def test_asarray(key: chex.PRNGKey) -> None:

From 668716624074e1a4b2d2eb473aef4a21426ebf2c Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 20 Nov 2023 21:42:58 +0900
Subject: [PATCH 082/337] Fix constant food

---
 src/emevo/environments/circle_foraging.py |  6 +----
 src/emevo/environments/env_utils.py       | 16 +++++++-------
 src/emevo/environments/phyjax2d_utils.py  | 27 ++++++++++-------------
 tests/test_placement.py                   |  4 ++--
 4 files changed, 23 insertions(+), 30 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index a58df1e4..8004a1b3 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -558,11 +558,7 @@ def step(
             velocity=stated.circle.v.xy,
             angular_velocity=stated.circle.v.angle,
         )
-        timestep = TimeStep(
-            encount=c2c,
-            obs=obs,
-            info={"contacts": contacts, "foods": jnp.max(c2sc, axis=0)},
-        )
+        timestep = TimeStep(encount=c2c, obs=obs)
         # Remove and reproduce foods
         key, food_key = jax.random.split(state.key)
         stated, food_num, food_loc = self._remove_and_reproduce_foods(
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index 77d12c48..ee0c752a 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -11,7 +11,7 @@
 from jax.typing import ArrayLike
 
 from emevo.environments.phyjax2d import ShapeDict, StateDict
-from emevo.environments.phyjax2d_utils import circle_overwrap
+from emevo.environments.phyjax2d_utils import circle_overlap
 
 Self = Any
 
@@ -44,7 +44,7 @@ class ReprNumConstant:
 
     def __call__(self, state: FoodNumState) -> FoodNumState:
         # Do nothing here
-        return state.replace(internal=self.initial)
+        return state.replace(internal=jnp.array(self.initial, dtype=jnp.float32))
 
 
 @dataclasses.dataclass(frozen=True)
@@ -264,9 +264,6 @@ def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
         return jax.lax.switch(index, self._locfn_list, key, state)
 
 
-_vmap_co = jax.vmap(circle_overwrap, in_axes=(None, None, 0, None))
-
-
 def first_true(boolean_array: jax.Array) -> jax.Array:
     return jnp.logical_and(boolean_array, jnp.cumsum(boolean_array) == 1)
 
@@ -286,9 +283,12 @@ def place(
     vmap_loc_fn = jax.vmap(loc_fn, in_axes=(0, None))
     locations = vmap_loc_fn(keys, loc_state)
     contains_fn = jax.vmap(coordinate.contains_circle, in_axes=(0, None))
-    ok = jnp.logical_and(
-        contains_fn(locations, radius),
-        jnp.logical_not(_vmap_co(shaped, stated, locations, radius)),
+    overlap = jax.vmap(circle_overlap, in_axes=(None, None, 0, None))(
+        shaped,
+        stated,
+        locations,
+        radius,
     )
+    ok = jnp.logical_and(contains_fn(locations, radius), jnp.logical_not(overlap))
     mask = jnp.expand_dims(first_true(ok), axis=1)
     return jnp.sum(mask * locations, axis=0), jnp.any(ok)
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 322b17d5..b7470c59 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -280,34 +280,33 @@ def make_square(
     return lines
 
 
-def circle_overwrap(
+def circle_overlap(
     shaped: ShapeDict,
     stated: StateDict,
     xy: jax.Array,
     radius: jax.Array,
 ) -> jax.Array:
-    # Circle-circle overwrap
-
+    # Circle overlap
     if stated.circle is not None and shaped.circle is not None:
         cpos = stated.circle.p.xy
         # Suppose that cpos.shape == (N, 2) and xy.shape == (2,)
         dist = jnp.linalg.norm(cpos - jnp.expand_dims(xy, axis=0), axis=-1)
         penetration = shaped.circle.radius + radius - dist
-        has_overwrap = jnp.logical_and(stated.circle.is_active, penetration >= 0)
-        overwrap2cir = jnp.any(has_overwrap)
+        has_overlap = jnp.logical_and(stated.circle.is_active, penetration >= 0)
+        overlap = jnp.any(has_overlap)
     else:
-        overwrap2cir = jnp.array(False)
+        overlap = jnp.array(False)
 
-    # Circle-static_circle overwrap
+    # Static_circle overlap
     if stated.static_circle is not None and shaped.static_circle is not None:
         cpos = stated.static_circle.p.xy
         # Suppose that cpos.shape == (N, 2) and xy.shape == (2,)
         dist = jnp.linalg.norm(cpos - jnp.expand_dims(xy, axis=0), axis=-1)
         penetration = shaped.static_circle.radius + radius - dist
-        has_overwrap = jnp.logical_and(stated.static_circle.is_active, penetration >= 0)
-        overwrap2cir = jnp.logical_or(jnp.any(has_overwrap), overwrap2cir)
+        has_overlap = jnp.logical_and(stated.static_circle.is_active, penetration >= 0)
+        overlap = jnp.logical_or(jnp.any(has_overlap), overlap)
 
-    # Circle-segment overwrap
+    # Circle-segment overlap
 
     if stated.segment is not None and shaped.segment is not None:
         spos = stated.segment.p
@@ -322,9 +321,7 @@ def circle_overwrap(
         pa = jnp.where(in_segment, p1 + edge * s1 / ee, jnp.where(s1 < 0.0, p1, p2))
         dist = jnp.linalg.norm(pb - pa, axis=-1)
         penetration = radius - dist
-        has_overwrap = jnp.logical_and(stated.segment.is_active, penetration >= 0)
-        overwrap2seg = jnp.any(has_overwrap)
-    else:
-        overwrap2seg = jnp.array(False)
+        has_overlap = jnp.logical_and(stated.segment.is_active, penetration >= 0)
+        overlap = jnp.logical_or(jnp.any(has_overlap), overlap)
 
-    return jnp.logical_or(overwrap2cir, overwrap2seg)
+    return overlap
diff --git a/tests/test_placement.py b/tests/test_placement.py
index eb8ccc4f..1cb81bde 100644
--- a/tests/test_placement.py
+++ b/tests/test_placement.py
@@ -64,7 +64,7 @@ def test_place_agents(key) -> None:
     )
     stated = stated.nested_replace("circle.is_active", is_active)
 
-    # test no overwrap each other
+    # test no overlap each other
     contact = space.check_contacts(stated)
     assert jnp.all(contact.penetration <= 0.0)
 
@@ -104,6 +104,6 @@ def test_place_foods(key) -> None:
     )
     stated = stated.nested_replace("static_circle.is_active", is_active)
 
-    # test no overwrap each other
+    # test no overlap each other
     contact = space.check_contacts(stated)
     assert jnp.all(contact.penetration <= 0.0)

From 3c9a522e0f39565a96ace46d1dc8e9483aff9f1d Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 21 Nov 2023 12:42:35 +0900
Subject: [PATCH 083/337] Fix initial location bug

---
 src/emevo/environments/circle_foraging.py | 4 ++--
 src/emevo/environments/env_utils.py       | 2 ++
 tests/test_env_utils.py                   | 1 -
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 8004a1b3..40ba29f7 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -646,7 +646,8 @@ def _initialize_physics_state(
         self,
         key: chex.PRNGKey,
     ) -> tuple[StateDict, LocatingState, LocatingState]:
-        stated = self._physics.shaped.zeros_state()
+        # Set segment
+        stated = self._physics.shaped.zeros_state().replace(segment=self._segment_state)
         assert stated.circle is not None
 
         # Set is_active
@@ -706,7 +707,6 @@ def _initialize_physics_state(
         if food_failed > 0:
             warnings.warn(f"Failed to place {food_failed} foods!", stacklevel=1)
 
-        stated = stated.replace(segment=self._segment_state)
         return stated, agentloc_state, foodloc_state
 
     def _remove_and_reproduce_foods(
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index ee0c752a..01fa73b1 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -290,5 +290,7 @@ def place(
         radius,
     )
     ok = jnp.logical_and(contains_fn(locations, radius), jnp.logical_not(overlap))
+    # print(locations)
+    # print(overlap)
     mask = jnp.expand_dims(first_true(ok), axis=1)
     return jnp.sum(mask * locations, axis=0), jnp.any(ok)
diff --git a/tests/test_env_utils.py b/tests/test_env_utils.py
index 8b17f78b..f2259647 100644
--- a/tests/test_env_utils.py
+++ b/tests/test_env_utils.py
@@ -72,7 +72,6 @@ def test_loc_periodic(key: chex.PRNGKey) -> None:
     for i in range(10):
         loc = loc_p(key, state)
         state = state.increment()
-        print(loc)
         assert jnp.all(loc == jnp.array(points[i % 3]))
 
 

From 69e70546322e578fe29bb0012de780f41658deb2 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 21 Nov 2023 18:06:18 +0900
Subject: [PATCH 084/337] Revert the change of action space

---
 smoke-tests/circle_ppo.py                 | 54 +++++++++++++++++------
 src/emevo/environments/circle_foraging.py | 26 +++++------
 2 files changed, 52 insertions(+), 28 deletions(-)

diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index d75def30..7657a097 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -30,19 +30,26 @@
 N_MAX_AGENTS: int = 10
 
 
+def weight_summary(network):
+    params, _ = eqx.partition(network, eqx.is_inexact_array)
+    params_mean = jax.tree_map(jnp.mean, params)
+    for k, v in jax.tree_util.tree_leaves_with_path(params_mean):
+        print(k, v)
+
+
 def visualize(
     key: chex.PRNGKey,
     env: Env,
     network: NormalPPONet,
     n_steps: int,
-    videoname: Path | None,
+    videopath: Path | None,
 ) -> None:
     keys = jax.random.split(key, n_steps + 1)
     state, ts = env.reset(keys[0])
     obs = ts.obs
     visualizer = env.visualizer(state, figsize=(640.0, 640.0))
-    if videoname is not None:
-        visualizer = SaveVideoWrapper(visualizer, videoname, fps=60)
+    if videopath is not None:
+        visualizer = SaveVideoWrapper(visualizer, videopath, fps=60)
 
     # Returns action for debugging
     @eqx.filter_jit
@@ -111,6 +118,7 @@ def training_step(
     opt_state: optax.OptState,
     minibatch_size: int,
     n_optim_epochs: int,
+    reset: jax.Array,
 ) -> tuple[State, Obs, jax.Array, optax.OptState, NormalPPONet]:
     keys = jax.random.split(prng_key, N_MAX_AGENTS + 1)
     env_state, rollout, obs, next_value = exec_rollout(
@@ -121,6 +129,7 @@ def training_step(
         keys[0],
         n_rollout_steps,
     )
+    rollout = rollout.replace(terminations=rollout.terminations.at[-1].set(reset))
     batch = vmap_batch(rollout, next_value, gamma, gae_lambda)
     output = vmap_apply(network, obs.as_array())
     opt_state, pponet = vmap_update(
@@ -132,7 +141,7 @@ def training_step(
         minibatch_size,
         n_optim_epochs,
         0.2,
-        0.01,
+        0.0,
     )
     return env_state, obs, rollout.rewards, opt_state, pponet
 
@@ -148,6 +157,8 @@ def run_training(
     minibatch_size: int,
     n_rollout_steps: int,
     n_total_steps: int,
+    reset_interval: int | None = None,
+    debug_vis: bool = False,
 ) -> NormalPPONet:
     key, net_key, reset_key = jax.random.split(key, 3)
     obs_space = env.obs_space.flatten()
@@ -167,8 +178,12 @@ def run_training(
     n_loop = n_total_steps // n_rollout_steps
     rewards = jnp.zeros(N_MAX_AGENTS)
     keys = jax.random.split(key, n_loop)
-    visualizer = env.visualizer(env_state, figsize=(640.0, 640.0))
-    for key in keys:
+    if debug_vis:
+        visualizer = env.visualizer(env_state, figsize=(640.0, 640.0))
+    else:
+        visualizer = None
+    for i, key in enumerate(keys):
+        reset = reset_interval is not None and (i + 1) % reset_interval
         env_state, obs, rewards_i, opt_state, pponet = training_step(
             env_state,
             obs,
@@ -182,12 +197,18 @@ def run_training(
             opt_state,
             minibatch_size,
             n_optim_epochs,
+            jnp.array(reset),
         )
-        visualizer.render(env_state)
-        visualizer.show()
+        if visualizer is not None:
+            visualizer.render(env_state)
+            visualizer.show()
         ri = jnp.sum(jnp.squeeze(rewards_i, axis=-1), axis=0)
         rewards = rewards + ri
         print(f"Rewards: {[x.item() for x in ri[: n_agents]]}")
+        if reset:
+            env_state, timestep = env.reset(key)
+            obs = timestep.obs
+        # weight_summary(pponet)
     print(f"Sum of rewards {[x.item() for x in rewards[: n_agents]]}")
     return pponet
 
@@ -211,9 +232,11 @@ def train(
     n_rollout_steps: int = 512,
     n_total_steps: int = 512 * 100,
     food_loc_fn: str = "gaussian",
-    env_shape: str = "square",
+    env_shape: str = "circle",
+    reset_interval: Optional[int] = None,
     xlim: int = 200,
     ylim: int = 200,
+    debug_vis: bool = False,
 ) -> None:
     assert n_agents < N_MAX_AGENTS
     env = make(
@@ -223,10 +246,12 @@ def train(
         n_initial_agents=n_agents,
         food_num_fn=("constant", n_foods),
         food_loc_fn=food_loc_fn,
+        agent_loc_fn="gaussian",
         foodloc_interval=20,
         obstacles=obstacles,
         xlim=(0.0, float(xlim)),
         ylim=(0.0, float(ylim)),
+        env_radius=min(xlim, ylim) * 0.5,
     )
     train_key, eval_key = jax.random.split(jax.random.PRNGKey(seed))
     network = run_training(
@@ -240,6 +265,8 @@ def train(
         minibatch_size,
         n_rollout_steps,
         n_total_steps,
+        reset_interval,
+        debug_vis,
     )
     if render:
         visualize(eval_key, env, network, 1000, videoname)
@@ -249,14 +276,14 @@ def train(
 @app.command()
 def vis(
     modelpath: Path = Path("trained.eqx"),
-    n_steps: int = 1000,
+    n_total_steps: int = 1000,
     seed: int = 1,
     n_agents: int = 2,
     n_foods: int = 10,
     food_loc_fn: str = "gaussian",
-    env_shape: str = "square",
+    env_shape: str = "circle",
     obstacles: str = "none",
-    videoname: Optional[str] = None,
+    videopath: Optional[str] = None,
     xlim: int = 200,
     ylim: int = 200,
 ) -> None:
@@ -272,6 +299,7 @@ def vis(
         obstacles=obstacles,
         xlim=(0.0, float(xlim)),
         ylim=(0.0, float(ylim)),
+        env_radius=min(xlim, ylim) * 0.5,
     )
     obs_space = env.obs_space.flatten()
     input_size = np.prod(obs_space.shape)
@@ -284,7 +312,7 @@ def vis(
         jax.random.split(net_key, N_MAX_AGENTS),
     )
     pponet = eqx.tree_deserialise_leaves(modelpath, pponet)
-    visualize(eval_key, env, pponet, n_steps, videoname)
+    visualize(eval_key, env, pponet, n_total_steps, videopath)
 
 
 if __name__ == "__main__":
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 40ba29f7..47a8c565 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -47,10 +47,7 @@
 
 MAX_ANGULAR_VELOCITY: float = float(np.pi)
 MAX_VELOCITY: float = 10.0
-MIN_ROT_FORCE: float = -10.0
-MAX_ROT_FORCE: float = 10.0
-MIN_PUSH_FORCE: float = -20.0
-MAX_PUSH_FORCE: float = 40.0
+MAX_FORCE: float = 40.0
 AGENT_COLOR: Color = Color(2, 204, 254)
 FOOD_COLOR: Color = Color(254, 2, 162)
 NOWHERE: float = -100.0
@@ -325,7 +322,7 @@ def __init__(
         angular_damping: float = 0.6,
         n_velocity_iter: int = 6,
         n_position_iter: int = 2,
-        n_physics_iter: int = 10,
+        n_physics_iter: int = 5,
         max_place_attempts: int = 10,
     ) -> None:
         # Coordinate and range
@@ -383,10 +380,7 @@ def __init__(
         self._food_indices = jnp.arange(n_max_foods)
         self._n_physics_iter = n_physics_iter
         # Spaces
-        self.act_space = BoxSpace(
-            low=jnp.array([MIN_ROT_FORCE, MIN_PUSH_FORCE]),
-            high=jnp.array([MAX_ROT_FORCE, MAX_PUSH_FORCE]),
-        )
+        self.act_space = BoxSpace(low=-MAX_FORCE * 0.5, high=MAX_FORCE, shape=(2,))
         self.obs_space = NamedTupleSpace(
             CFObs,
             sensor=BoxSpace(low=0.0, high=1.0, shape=(n_agent_sensors, N_OBJECTS)),
@@ -399,8 +393,10 @@ def __init__(
         self._n_sensors = n_agent_sensors
         # Some cached constants
         self._invisible_xy = jnp.ones(2) * NOWHERE
-        self._rot_p = jnp.tile(jnp.array([0.0, agent_radius]), (self._n_max_agents, 1))
-        self._push_p = jnp.zeros((self._n_max_agents, 2))
+        act_p1 = Vec2d(0, agent_radius).rotated(np.pi * 0.75)
+        act_p2 = Vec2d(0, agent_radius).rotated(-np.pi * 0.75)
+        self._act_p1 = jnp.tile(jnp.array(act_p1), (self._n_max_agents, 1))
+        self._act_p2 = jnp.tile(jnp.array(act_p2), (self._n_max_agents, 1))
         self._place_agent = jax.jit(
             functools.partial(
                 place,
@@ -527,11 +523,11 @@ def step(
         act = jax.vmap(self.act_space.clip)(jnp.array(action))
         f1 = jax.lax.slice_in_dim(act, 0, 1, axis=-1)
         f2 = jax.lax.slice_in_dim(act, 1, 2, axis=-1)
-        rot = jnp.concatenate((f1, jnp.zeros_like(f1)), axis=1)
-        push = jnp.concatenate((jnp.zeros_like(f2), f2), axis=1)
+        f1 = jnp.concatenate((jnp.zeros_like(f1), f1), axis=1)
+        f2 = jnp.concatenate((jnp.zeros_like(f2), f2), axis=1)
         circle = state.physics.circle
-        circle = circle.apply_force_local(self._rot_p, rot)
-        circle = circle.apply_force_local(self._push_p, push)
+        circle = circle.apply_force_local(self._act_p1, f1)
+        circle = circle.apply_force_local(self._act_p2, f2)
         stated = state.physics.replace(circle=circle)
         # Step physics simulator
         stated, solver, nstep_contacts = nstep(

From 5b73ed6dc8cb397401d1f04cec822d6faab69e1f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 21 Nov 2023 18:25:01 +0900
Subject: [PATCH 085/337] Add a bit more options to circle_ppo for debugging

---
 smoke-tests/circle_ppo.py                 | 23 ++++++++++++++++++++---
 src/emevo/environments/circle_foraging.py |  5 +++--
 2 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index 7657a097..ba11f692 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -218,6 +218,7 @@ def run_training(
 
 @app.command()
 def train(
+    modelpath: Path = Path("trained.eqx"),
     seed: int = 1,
     n_agents: int = 2,
     n_foods: int = 10,
@@ -229,13 +230,17 @@ def train(
     gae_lambda: float = 0.95,
     n_optim_epochs: int = 10,
     minibatch_size: int = 128,
-    n_rollout_steps: int = 512,
-    n_total_steps: int = 512 * 100,
+    n_rollout_steps: int = 1024,
+    n_total_steps: int = 1024 * 1000,
     food_loc_fn: str = "gaussian",
     env_shape: str = "circle",
     reset_interval: Optional[int] = None,
     xlim: int = 200,
     ylim: int = 200,
+    linear_damping: float = 0.8,
+    angular_damping: float = 0.6,
+    max_force: float = 40.0,
+    min_force: float = -20.0,
     debug_vis: bool = False,
 ) -> None:
     assert n_agents < N_MAX_AGENTS
@@ -252,6 +257,10 @@ def train(
         xlim=(0.0, float(xlim)),
         ylim=(0.0, float(ylim)),
         env_radius=min(xlim, ylim) * 0.5,
+        linear_damping=linear_damping,
+        angular_damping=angular_damping,
+        max_force=max_force,
+        min_force=min_force,
     )
     train_key, eval_key = jax.random.split(jax.random.PRNGKey(seed))
     network = run_training(
@@ -270,7 +279,7 @@ def train(
     )
     if render:
         visualize(eval_key, env, network, 1000, videoname)
-    eqx.tree_serialise_leaves("trained.eqx", network)
+    eqx.tree_serialise_leaves(modelpath, network)
 
 
 @app.command()
@@ -286,6 +295,10 @@ def vis(
     videopath: Optional[str] = None,
     xlim: int = 200,
     ylim: int = 200,
+    linear_damping: float = 0.8,
+    angular_damping: float = 0.6,
+    max_force: float = 40.0,
+    min_force: float = -20.0,
 ) -> None:
     assert n_agents < N_MAX_AGENTS
     env = make(
@@ -300,6 +313,10 @@ def vis(
         xlim=(0.0, float(xlim)),
         ylim=(0.0, float(ylim)),
         env_radius=min(xlim, ylim) * 0.5,
+        linear_damping=linear_damping,
+        angular_damping=angular_damping,
+        max_force=max_force,
+        min_force=min_force,
     )
     obs_space = env.obs_space.flatten()
     input_size = np.prod(obs_space.shape)
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 47a8c565..8944c0ea 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -47,7 +47,6 @@
 
 MAX_ANGULAR_VELOCITY: float = float(np.pi)
 MAX_VELOCITY: float = 10.0
-MAX_FORCE: float = 40.0
 AGENT_COLOR: Color = Color(2, 204, 254)
 FOOD_COLOR: Color = Color(254, 2, 162)
 NOWHERE: float = -100.0
@@ -320,6 +319,8 @@ def __init__(
         dt: float = 0.1,
         linear_damping: float = 0.8,
         angular_damping: float = 0.6,
+        max_force: float = 40.0,
+        min_force: float = -20.0,
         n_velocity_iter: int = 6,
         n_position_iter: int = 2,
         n_physics_iter: int = 5,
@@ -380,7 +381,7 @@ def __init__(
         self._food_indices = jnp.arange(n_max_foods)
         self._n_physics_iter = n_physics_iter
         # Spaces
-        self.act_space = BoxSpace(low=-MAX_FORCE * 0.5, high=MAX_FORCE, shape=(2,))
+        self.act_space = BoxSpace(low=min_force, high=max_force, shape=(2,))
         self.obs_space = NamedTupleSpace(
             CFObs,
             sensor=BoxSpace(low=0.0, high=1.0, shape=(n_agent_sensors, N_OBJECTS)),

From ee6ee9e4047b6c61b05f9c8a61a8213dba9616be Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 21 Nov 2023 18:57:58 +0900
Subject: [PATCH 086/337] Remove unused imports

---
 smoke-tests/circle_ppo.py | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index ba11f692..c92150c8 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -1,6 +1,5 @@
 """Example of using circle foraging environment"""
 
-import datetime
 from pathlib import Path
 from typing import Optional
 
@@ -11,9 +10,8 @@
 import numpy as np
 import optax
 import typer
-from tqdm import tqdm
 
-from emevo import Env, Visualizer, make
+from emevo import Env, make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
 from emevo.rl.ppo_normal import (
@@ -223,10 +221,9 @@ def train(
     n_agents: int = 2,
     n_foods: int = 10,
     obstacles: str = "none",
-    render: bool = False,
     adam_lr: float = 3e-4,
     adam_eps: float = 1e-7,
-    gamma: float = 0.99,
+    gamma: float = 0.999,
     gae_lambda: float = 0.95,
     n_optim_epochs: int = 10,
     minibatch_size: int = 128,
@@ -277,8 +274,6 @@ def train(
         reset_interval,
         debug_vis,
     )
-    if render:
-        visualize(eval_key, env, network, 1000, videoname)
     eqx.tree_serialise_leaves(modelpath, network)
 
 

From 6a976acc9e981f61ae4aeacdc9d99dd8c3468a56 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 22 Nov 2023 12:55:06 +0900
Subject: [PATCH 087/337] Headless rendering

---
 smoke-tests/circle_ppo.py                 | 20 +++++++++++---------
 src/emevo/environments/circle_foraging.py |  4 ++--
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index c92150c8..fda24bb7 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -41,11 +41,13 @@ def visualize(
     network: NormalPPONet,
     n_steps: int,
     videopath: Path | None,
+    headless: bool,
 ) -> None:
     keys = jax.random.split(key, n_steps + 1)
     state, ts = env.reset(keys[0])
     obs = ts.obs
-    visualizer = env.visualizer(state, figsize=(640.0, 640.0))
+    backend = "headless" if headless else "pyglet"
+    visualizer = env.visualizer(state, figsize=(640.0, 640.0), backend=backend)
     if videopath is not None:
         visualizer = SaveVideoWrapper(visualizer, videopath, fps=60)
 
@@ -59,7 +61,7 @@ def step(key: chex.PRNGKey, state: State, obs: Obs) -> tuple[State, Obs, jax.Arr
 
     for key in keys[1:]:
         state, obs, act = step(key, state, obs)
-        print(f"Act: {act[0]}")
+        # print(f"Act: {act[0]}")
         visualizer.render(state)
         visualizer.show()
 
@@ -197,12 +199,12 @@ def run_training(
             n_optim_epochs,
             jnp.array(reset),
         )
+        ri = jnp.sum(jnp.squeeze(rewards_i, axis=-1), axis=0)
+        rewards = rewards + ri
         if visualizer is not None:
             visualizer.render(env_state)
             visualizer.show()
-        ri = jnp.sum(jnp.squeeze(rewards_i, axis=-1), axis=0)
-        rewards = rewards + ri
-        print(f"Rewards: {[x.item() for x in ri[: n_agents]]}")
+            print(f"Rewards: {[x.item() for x in ri[: n_agents]]}")
         if reset:
             env_state, timestep = env.reset(key)
             obs = timestep.obs
@@ -259,9 +261,8 @@ def train(
         max_force=max_force,
         min_force=min_force,
     )
-    train_key, eval_key = jax.random.split(jax.random.PRNGKey(seed))
     network = run_training(
-        train_key,
+        jax.random.PRNGKey(seed),
         n_agents,
         env,
         optax.adam(adam_lr, eps=adam_eps),
@@ -287,13 +288,14 @@ def vis(
     food_loc_fn: str = "gaussian",
     env_shape: str = "circle",
     obstacles: str = "none",
-    videopath: Optional[str] = None,
+    videopath: Optional[Path] = None,
     xlim: int = 200,
     ylim: int = 200,
     linear_damping: float = 0.8,
     angular_damping: float = 0.6,
     max_force: float = 40.0,
     min_force: float = -20.0,
+    headless: bool = False,
 ) -> None:
     assert n_agents < N_MAX_AGENTS
     env = make(
@@ -324,7 +326,7 @@ def vis(
         jax.random.split(net_key, N_MAX_AGENTS),
     )
     pponet = eqx.tree_deserialise_leaves(modelpath, pponet)
-    visualize(eval_key, env, pponet, n_total_steps, videopath)
+    visualize(eval_key, env, pponet, n_total_steps, videopath, headless)
 
 
 if __name__ == "__main__":
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 8944c0ea..345764d1 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -742,7 +742,7 @@ def visualizer(
         self,
         state: CFState,
         figsize: tuple[float, float] | None = None,
-        mgl_backend: str = "pyglet",
+        backend: str = "pyglet",
         **kwargs,
     ) -> Visualizer:
         """Create a visualizer for the environment"""
@@ -754,7 +754,7 @@ def visualizer(
             space=self._physics,
             stated=state.physics,
             figsize=figsize,
-            backend=mgl_backend,
+            backend=backend,
             sensor_fn=self._get_sensors,
             **kwargs,
         )

From e3b1c28f9ffe6c8a8a4c09bd9bb93c902b29cf66 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 22 Nov 2023 17:19:13 +0900
Subject: [PATCH 088/337] Start implementing jax version of birth and death

---
 pyproject.toml               |   1 +
 src/emevo/birth_and_death.py | 319 +++++++++++++++++++++++++++++++++++
 2 files changed, 320 insertions(+)
 create mode 100644 src/emevo/birth_and_death.py

diff --git a/pyproject.toml b/pyproject.toml
index 8d9c043c..1e823770 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -24,6 +24,7 @@ dependencies = [
     "equinox >= 0.11",
     "jax >= 0.4",
     "optax >= 0.1",
+    "scipy >= 1.0",
 ]
 dynamic = ["version"]
 
diff --git a/src/emevo/birth_and_death.py b/src/emevo/birth_and_death.py
new file mode 100644
index 00000000..dcca992b
--- /dev/null
+++ b/src/emevo/birth_and_death.py
@@ -0,0 +1,319 @@
+""" Evaluate birth and death probabilities.
+"""
+import dataclasses
+from typing import Protocol
+
+import jax
+import jax.numpy as jnp
+from scipy import integrate
+
+from emevo.status import Status
+
+
+class HazardFunction(Protocol):
+    def __call__(self, status: Status) -> jax.Array:
+        """Hazard function h(t)"""
+        ...
+
+    def cumulative(self, status: Status) -> jax.Array:
+        """Cumulative hazard function H(t) = ∫h(t)"""
+        ...
+
+    def survival(self, status: Status) -> jax.Array:
+        """Survival Rate S(t) = exp(-H(t))"""
+        return jnp.exp(-self.cumulative(status))
+
+
+@dataclasses.dataclass
+class Deterministic(HazardFunction):
+    """
+    A deterministic hazard function where an agent dies when
+    - its energy level is lower than the energy thershold or
+    - its age is older than the the age thershold
+    """
+
+    energy_threshold: float
+    age_threshold: float
+
+    def __call__(self, status: Status) -> jax.Array:
+        res = jnp.logical_or(
+            status.energy < self.energy_threshold,
+            self.age_threshold < status.age,
+        )
+        return res.astype(jnp.float32)
+
+    def cumulative(self, status: Status) -> jax.Array:
+        return jnp.where(
+            status.energy < self.energy_threshold,
+            status.age,
+            jnp.where(
+                self.age_threshold < status.age,
+                status.age - self.age_threshold,
+                0.0,
+            ),
+        )
+
+
+@dataclasses.dataclass
+class Constant(HazardFunction):
+    """
+    Hazard with constant death rate.
+    Energy
+    α = α_const + α_energy * exp(-γenergy)
+    h(t) = α
+    H(t) = αt
+    S(t) = exp(-αt)
+    """
+
+    alpha_const: float = 1e-5
+    alpha_energy: float = 1e-6
+    gamma: float = 1.0
+
+    def _alpha(self, status: Status) -> jax.Array:
+        alpha_energy = self.alpha_energy * jnp.exp(-self.gamma * status.energy)
+        return self.alpha_const + alpha_energy
+
+    def __call__(self, status: Status) -> jax.Array:
+        return self._alpha(status)
+
+    def cumulative(self, status: Status) -> jax.Array:
+        return self(status) * status.age
+
+
+@dataclasses.dataclass
+class EnergyLogistic(HazardFunction):
+    """
+    Hazard with death rate that only depends on energy.
+    h(e) = h_max (1 - 1 / (1 + αexp(e0 - e))
+    """
+
+    alpha: float = 1.0
+    hmax: float = 1.0
+    e0: float = 3.0
+
+    def _energy_death_rate(self, energy: jax.Array) -> jax.Array:
+        exp_neg_energy = self.alpha * jnp.exp(self.e0 - energy)
+        return self.hmax * (1.0 - 1.0 / (1.0 + self.alpha * exp_neg_energy))
+
+    def __call__(self, status: Status) -> jax.Array:
+        return self._energy_death_rate(status.energy)
+
+    def cumulative(self, status: Status) -> jax.Array:
+        return self._energy_death_rate(status.energy) * status.age
+
+
+@dataclasses.dataclass
+class Gompertz(Constant):
+    """
+    Hazard with exponentially increasing death rate.
+    α = α_const + α_energy * exp(-γenergy)
+    h(t) = α exp(βt)
+    H(t) = α/β exp(βt)
+    S(t) = exp(-H(t))
+    """
+
+    beta: float = 1e-5
+
+    def __call__(self, status: Status) -> jax.Array:
+        return self._alpha(status) * jnp.exp(self.beta * status.age)
+
+    def cumulative(self, status: Status) -> jax.Array:
+        alpha = self._alpha(status)
+        ht = alpha / self.beta * jnp.exp(self.beta * status.age)
+        h0 = alpha / self.beta
+        return ht - h0
+
+
+@dataclasses.dataclass
+class EnergyLogGompertz(EnergyLogistic):
+    """
+    Exponentially increasing with time + EnergyLogistic
+    h(e) = h_max (1 - 1 / (1 + αexp(e0 - e))
+    h(t) = αexp(βt) + h(e)
+    H(t) = α/β exp(βt) + h(e)t
+    S(t) = exp(-H(t))
+    """
+
+    alpha_age: float = 1e-6
+    beta: float = 1e-5
+
+    def __call__(self, status: Status) -> jax.Array:
+        age = self.alpha_age * jnp.exp(self.beta * status.age)
+        energy = self._energy_death_rate(status.energy)
+        return age + energy
+
+    def cumulative(self, status: Status) -> jax.Array:
+        energy = self._energy_death_rate(status.energy) * status.age
+        ht = energy + self.alpha_age / self.beta * jnp.exp(self.beta * status.age)
+        h0 = self.alpha_age / self.beta
+        return ht - h0
+
+
+def cumulative_hazard(
+    hazard: HazardFunction,
+    *,
+    energy: float = 0.0,
+    max_age: float = 1e6,
+) -> float:
+    status = Status(
+        age=jnp.array(0),
+        energy=jnp.array(energy),
+        is_alive=jnp.array(True),
+    )
+    result = integrate.quad(
+        lambda t: hazard(status.replace(t=jnp.array(t))),
+        0.0,
+        max_age,
+        limit=10000,
+    )
+    return result[0]
+
+
+class BirthFunction(Protocol):
+    def asexual(self, status: Status) -> jax.Array:
+        """Birth function b(t)"""
+        ...
+
+    def sexual(self, status_a: Status, status_b: Status) -> jax.Array:
+        """Birth function b(t)"""
+        ...
+
+
+@dataclasses.dataclass
+class Logistic(BirthFunction):
+    scale: float
+    alpha: float = 1.0
+    beta: float = 0.001
+    age_delay: float = 1000.0
+    energy_delay: float = 8.0
+
+    def _exp_age(self, age: jax.Array) -> jax.Array:
+        return jnp.exp(-self.beta * (age - self.age_delay))
+
+    def _exp_neg_energy(self, energy: float) -> jax.Array:
+        return jnp.exp(self.energy_delay - energy)
+
+    def asexual(self, status: Status) -> jax.Array:
+        exp_neg_age = self._exp_age(status.age)
+        exp_neg_energy = self._exp_neg_energy(status.energy)
+        return self.scale / (1.0 + self.alpha * (exp_neg_age + exp_neg_energy))
+
+    def sexual(self, status_a: Status, status_b: Status) -> jax.Array:
+        exp_neg_age_a = self._exp_age(status_a.age)
+        exp_neg_energy_a = self._exp_neg_energy(status_a.energy)
+        exp_neg_age_b = self._exp_age(status_b.age)
+        exp_neg_energy_b = self._exp_neg_energy(status_b.energy)
+        sum_exp = exp_neg_age_a + exp_neg_energy_a + exp_neg_age_b + exp_neg_energy_b
+        return self.scale / (1.0 + self.alpha * sum_exp)
+
+
+@dataclasses.dataclass
+class EnergyLogistic(BirthFunction):
+    """
+    Only energy is important to give birth.
+    b(t) = scale / (1.0 + α x exp(delay - e(t)))
+    """
+
+    scale: float
+    alpha: float = 1.0
+    delay: float = 8.0
+
+    def _exp_neg_energy(self, energy: jax.Array) -> jax.Array:
+        return jnp.exp(self.delay - energy)
+
+    def asexual(self, status: Status) -> jax.Array:
+        exp_neg_energy = self._exp_neg_energy(status.energy)
+        return self.scale / (1.0 + self.alpha * exp_neg_energy)
+
+    def sexual(self, status_a: Status, status_b: Status) -> jax.Array:
+        exp_neg_energy_a = self._exp_neg_energy(status_a.energy)
+        exp_neg_energy_b = self._exp_neg_energy(status_b.energy)
+        sum_exp = exp_neg_energy_a + exp_neg_energy_b
+        return self.scale / (1.0 + self.alpha * sum_exp)
+
+
+@dataclasses.dataclass
+class EnergyLogisticMeta(BirthFunction):
+    """
+    Only energy is important to give birth.
+    Note that all fields in metadata should have 'birth_' prefix.
+    """
+
+    scale: float
+    alpha: float = 1.0
+    delay: float = 8.0
+
+    def _exp_neg_energy(self, status: Status) -> jax.Array:
+        assert status.metadata is not None
+        energy_delay = status.metadata.get("birth_delay", self.delay)
+        return jnp.exp(energy_delay - status.energy)
+
+    def asexual(self, status: Status) -> jax.Array:
+        assert status.metadata is not None
+        exp_neg_energy = self._exp_neg_energy(status)
+        scale = status.metadata.get("birth_scale", self.scale)
+        alpha = status.metadata.get("birth_alpha", self.alpha)
+        return scale / (1.0 + alpha * exp_neg_energy)
+
+    def sexual(self, status_a: Status, status_b: Status) -> jax.Array:
+        assert status_a.metadata is not None and status_b.metadata is not None
+        exp_neg_energy_a = self._exp_neg_energy(status_a)
+        exp_neg_energy_b = self._exp_neg_energy(status_b)
+        sum_exp = exp_neg_energy_a + exp_neg_energy_b
+        scale_a = status_a.metadata.get("birth_scale", self.scale)
+        alpha_a = status_a.metadata.get("birth_alpha", self.alpha)
+        scale_b = status_b.metadata.get("birth_scale", self.scale)
+        alpha_b = status_b.metadata.get("birth_alpha", self.alpha)
+        scale = (scale_a + scale_b) / 2
+        alpha = (alpha_a + alpha_b) / 2
+        return scale / (1.0 + alpha * sum_exp)
+
+
+def cumulative_survival(
+    hazard: HazardFunction,
+    *,
+    energy: float = 0.0,
+    max_age: float = 1e6,
+) -> float:
+    status = Status(
+        age=jnp.array(0),
+        energy=jnp.array(energy),
+        is_alive=jnp.array(True),
+    )
+    result = integrate.quad(
+        lambda t: hazard.survival(status.replace(t=jnp.array(t))).item(),
+        0,
+        max_age,
+    )
+    return result[0]
+
+
+def stable_birth_rate(
+    hazard: HazardFunction,
+    *,
+    energy: float = 0.0,
+    max_age: float = 1e6,
+) -> float:
+    cumsuv = cumulative_survival(hazard, energy=energy, max_age=max_age)
+    return 1.0 / cumsuv
+
+
+def expected_n_children(
+    *,
+    birth: BirthFunction,
+    hazard: HazardFunction,
+    max_age: float = 1e6,
+    asexual: bool = False,
+    **status_kwargs,
+) -> float:
+    def integrated(t: int) -> float:
+        status = Status(age=t, **status_kwargs)
+        if asexual:
+            b = birth.asexual(status)
+        else:
+            b = birth.sexual(status, status)
+        h = hazard.survival(status).item()
+        return h * b
+
+    result = integrate.quad(integrated, 0, max_age)
+    return result[0]

From d1945dcc0507e54299a4a933473d2ae40dccf9c0 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 24 Nov 2023 15:04:54 +0900
Subject: [PATCH 089/337] Don't use status in birth and death functions

---
 src/emevo/birth_and_death.py | 237 ++++++++++++++++-------------------
 1 file changed, 109 insertions(+), 128 deletions(-)

diff --git a/src/emevo/birth_and_death.py b/src/emevo/birth_and_death.py
index dcca992b..1379a6d8 100644
--- a/src/emevo/birth_and_death.py
+++ b/src/emevo/birth_and_death.py
@@ -7,25 +7,23 @@
 import jax.numpy as jnp
 from scipy import integrate
 
-from emevo.status import Status
-
 
 class HazardFunction(Protocol):
-    def __call__(self, status: Status) -> jax.Array:
+    def __call__(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         """Hazard function h(t)"""
         ...
 
-    def cumulative(self, status: Status) -> jax.Array:
+    def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         """Cumulative hazard function H(t) = ∫h(t)"""
         ...
 
-    def survival(self, status: Status) -> jax.Array:
+    def survival(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         """Survival Rate S(t) = exp(-H(t))"""
-        return jnp.exp(-self.cumulative(status))
+        return jnp.exp(-self.cumulative(age, energy))
 
 
 @dataclasses.dataclass
-class Deterministic(HazardFunction):
+class DeterministicHazard(HazardFunction):
     """
     A deterministic hazard function where an agent dies when
     - its energy level is lower than the energy thershold or
@@ -35,27 +33,27 @@ class Deterministic(HazardFunction):
     energy_threshold: float
     age_threshold: float
 
-    def __call__(self, status: Status) -> jax.Array:
+    def __call__(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         res = jnp.logical_or(
-            status.energy < self.energy_threshold,
-            self.age_threshold < status.age,
+            energy < self.energy_threshold,
+            self.age_threshold < age,
         )
         return res.astype(jnp.float32)
 
-    def cumulative(self, status: Status) -> jax.Array:
+    def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         return jnp.where(
-            status.energy < self.energy_threshold,
-            status.age,
+            energy < self.energy_threshold,
+            age,
             jnp.where(
-                self.age_threshold < status.age,
-                status.age - self.age_threshold,
+                self.age_threshold < age,
+                age - self.age_threshold,
                 0.0,
             ),
         )
 
 
 @dataclasses.dataclass
-class Constant(HazardFunction):
+class ConstantHazard(HazardFunction):
     """
     Hazard with constant death rate.
     Energy
@@ -69,19 +67,19 @@ class Constant(HazardFunction):
     alpha_energy: float = 1e-6
     gamma: float = 1.0
 
-    def _alpha(self, status: Status) -> jax.Array:
-        alpha_energy = self.alpha_energy * jnp.exp(-self.gamma * status.energy)
+    def _alpha(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        alpha_energy = self.alpha_energy * jnp.exp(-self.gamma * energy)
         return self.alpha_const + alpha_energy
 
-    def __call__(self, status: Status) -> jax.Array:
+    def __call__(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         return self._alpha(status)
 
-    def cumulative(self, status: Status) -> jax.Array:
-        return self(status) * status.age
+    def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        return self(status) * age
 
 
 @dataclasses.dataclass
-class EnergyLogistic(HazardFunction):
+class EnergyLogisticHazard(HazardFunction):
     """
     Hazard with death rate that only depends on energy.
     h(e) = h_max (1 - 1 / (1 + αexp(e0 - e))
@@ -95,15 +93,15 @@ def _energy_death_rate(self, energy: jax.Array) -> jax.Array:
         exp_neg_energy = self.alpha * jnp.exp(self.e0 - energy)
         return self.hmax * (1.0 - 1.0 / (1.0 + self.alpha * exp_neg_energy))
 
-    def __call__(self, status: Status) -> jax.Array:
-        return self._energy_death_rate(status.energy)
+    def __call__(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        return self._energy_death_rate(energy)
 
-    def cumulative(self, status: Status) -> jax.Array:
-        return self._energy_death_rate(status.energy) * status.age
+    def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        return self._energy_death_rate(energy) * age
 
 
 @dataclasses.dataclass
-class Gompertz(Constant):
+class GompertzHazard(ConstantHazard):
     """
     Hazard with exponentially increasing death rate.
     α = α_const + α_energy * exp(-γenergy)
@@ -114,18 +112,18 @@ class Gompertz(Constant):
 
     beta: float = 1e-5
 
-    def __call__(self, status: Status) -> jax.Array:
-        return self._alpha(status) * jnp.exp(self.beta * status.age)
+    def __call__(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        return self._alpha(status) * jnp.exp(self.beta * age)
 
-    def cumulative(self, status: Status) -> jax.Array:
+    def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         alpha = self._alpha(status)
-        ht = alpha / self.beta * jnp.exp(self.beta * status.age)
+        ht = alpha / self.beta * jnp.exp(self.beta * age)
         h0 = alpha / self.beta
         return ht - h0
 
 
 @dataclasses.dataclass
-class EnergyLogGompertz(EnergyLogistic):
+class ELGompertz(EnergyLogisticHazard):
     """
     Exponentially increasing with time + EnergyLogistic
     h(e) = h_max (1 - 1 / (1 + αexp(e0 - e))
@@ -137,50 +135,36 @@ class EnergyLogGompertz(EnergyLogistic):
     alpha_age: float = 1e-6
     beta: float = 1e-5
 
-    def __call__(self, status: Status) -> jax.Array:
-        age = self.alpha_age * jnp.exp(self.beta * status.age)
-        energy = self._energy_death_rate(status.energy)
+    def __call__(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        age = self.alpha_age * jnp.exp(self.beta * age)
+        energy = self._energy_death_rate(energy)
         return age + energy
 
-    def cumulative(self, status: Status) -> jax.Array:
-        energy = self._energy_death_rate(status.energy) * status.age
-        ht = energy + self.alpha_age / self.beta * jnp.exp(self.beta * status.age)
+    def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        energy = self._energy_death_rate(energy) * age
+        ht = energy + self.alpha_age / self.beta * jnp.exp(self.beta * age)
         h0 = self.alpha_age / self.beta
         return ht - h0
 
 
-def cumulative_hazard(
-    hazard: HazardFunction,
-    *,
-    energy: float = 0.0,
-    max_age: float = 1e6,
-) -> float:
-    status = Status(
-        age=jnp.array(0),
-        energy=jnp.array(energy),
-        is_alive=jnp.array(True),
-    )
-    result = integrate.quad(
-        lambda t: hazard(status.replace(t=jnp.array(t))),
-        0.0,
-        max_age,
-        limit=10000,
-    )
-    return result[0]
-
-
 class BirthFunction(Protocol):
-    def asexual(self, status: Status) -> jax.Array:
+    def asexual(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         """Birth function b(t)"""
         ...
 
-    def sexual(self, status_a: Status, status_b: Status) -> jax.Array:
+    def sexual(
+        self,
+        age_a: jax.Array,
+        energy_a: jax.Array,
+        age_b: jax.Array,
+        energy_b: jax.Array,
+    ) -> jax.Array:
         """Birth function b(t)"""
         ...
 
 
 @dataclasses.dataclass
-class Logistic(BirthFunction):
+class LogisticBirth(BirthFunction):
     scale: float
     alpha: float = 1.0
     beta: float = 0.001
@@ -190,25 +174,31 @@ class Logistic(BirthFunction):
     def _exp_age(self, age: jax.Array) -> jax.Array:
         return jnp.exp(-self.beta * (age - self.age_delay))
 
-    def _exp_neg_energy(self, energy: float) -> jax.Array:
+    def _exp_neg_energy(self, energy: jax.Array) -> jax.Array:
         return jnp.exp(self.energy_delay - energy)
 
-    def asexual(self, status: Status) -> jax.Array:
-        exp_neg_age = self._exp_age(status.age)
-        exp_neg_energy = self._exp_neg_energy(status.energy)
+    def asexual(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        exp_neg_age = self._exp_age(age)
+        exp_neg_energy = self._exp_neg_energy(energy)
         return self.scale / (1.0 + self.alpha * (exp_neg_age + exp_neg_energy))
 
-    def sexual(self, status_a: Status, status_b: Status) -> jax.Array:
-        exp_neg_age_a = self._exp_age(status_a.age)
-        exp_neg_energy_a = self._exp_neg_energy(status_a.energy)
-        exp_neg_age_b = self._exp_age(status_b.age)
-        exp_neg_energy_b = self._exp_neg_energy(status_b.energy)
+    def sexual(
+        self,
+        age_a: jax.Array,
+        energy_a: jax.Array,
+        age_b: jax.Array,
+        energy_b: jax.Array,
+    ) -> jax.Array:
+        exp_neg_age_a = self._exp_age(age_a)
+        exp_neg_energy_a = self._exp_neg_energy(energy_a)
+        exp_neg_age_b = self._exp_age(age_b)
+        exp_neg_energy_b = self._exp_neg_energy(energy_b)
         sum_exp = exp_neg_age_a + exp_neg_energy_a + exp_neg_age_b + exp_neg_energy_b
         return self.scale / (1.0 + self.alpha * sum_exp)
 
 
 @dataclasses.dataclass
-class EnergyLogistic(BirthFunction):
+class EnergyLogisticBirth(BirthFunction):
     """
     Only energy is important to give birth.
     b(t) = scale / (1.0 + α x exp(delay - e(t)))
@@ -221,80 +211,65 @@ class EnergyLogistic(BirthFunction):
     def _exp_neg_energy(self, energy: jax.Array) -> jax.Array:
         return jnp.exp(self.delay - energy)
 
-    def asexual(self, status: Status) -> jax.Array:
-        exp_neg_energy = self._exp_neg_energy(status.energy)
+    def asexual(self, _age: jax.Array, energy: jax.Array) -> jax.Array:
+        exp_neg_energy = self._exp_neg_energy(energy)
         return self.scale / (1.0 + self.alpha * exp_neg_energy)
 
-    def sexual(self, status_a: Status, status_b: Status) -> jax.Array:
-        exp_neg_energy_a = self._exp_neg_energy(status_a.energy)
-        exp_neg_energy_b = self._exp_neg_energy(status_b.energy)
+    def sexual(
+        self,
+        _age_a: jax.Array,
+        energy_a: jax.Array,
+        _age_b: jax.Array,
+        energy_b: jax.Array,
+    ) -> jax.Array:
+        del _age_a, _age_b
+        exp_neg_energy_a = self._exp_neg_energy(energy_a)
+        exp_neg_energy_b = self._exp_neg_energy(energy_b)
         sum_exp = exp_neg_energy_a + exp_neg_energy_b
         return self.scale / (1.0 + self.alpha * sum_exp)
 
 
-@dataclasses.dataclass
-class EnergyLogisticMeta(BirthFunction):
-    """
-    Only energy is important to give birth.
-    Note that all fields in metadata should have 'birth_' prefix.
-    """
-
-    scale: float
-    alpha: float = 1.0
-    delay: float = 8.0
-
-    def _exp_neg_energy(self, status: Status) -> jax.Array:
-        assert status.metadata is not None
-        energy_delay = status.metadata.get("birth_delay", self.delay)
-        return jnp.exp(energy_delay - status.energy)
-
-    def asexual(self, status: Status) -> jax.Array:
-        assert status.metadata is not None
-        exp_neg_energy = self._exp_neg_energy(status)
-        scale = status.metadata.get("birth_scale", self.scale)
-        alpha = status.metadata.get("birth_alpha", self.alpha)
-        return scale / (1.0 + alpha * exp_neg_energy)
-
-    def sexual(self, status_a: Status, status_b: Status) -> jax.Array:
-        assert status_a.metadata is not None and status_b.metadata is not None
-        exp_neg_energy_a = self._exp_neg_energy(status_a)
-        exp_neg_energy_b = self._exp_neg_energy(status_b)
-        sum_exp = exp_neg_energy_a + exp_neg_energy_b
-        scale_a = status_a.metadata.get("birth_scale", self.scale)
-        alpha_a = status_a.metadata.get("birth_alpha", self.alpha)
-        scale_b = status_b.metadata.get("birth_scale", self.scale)
-        alpha_b = status_b.metadata.get("birth_alpha", self.alpha)
-        scale = (scale_a + scale_b) / 2
-        alpha = (alpha_a + alpha_b) / 2
-        return scale / (1.0 + alpha * sum_exp)
+def compute_cumulative_hazard(
+    hazard: HazardFunction,
+    *,
+    energy: float = 10.0,
+    max_age: float = 1e6,
+) -> float:
+    """Compute cumulative hazard using numeric integration"""
+    energy_arr = jnp.array(energy)
+    result = integrate.quad(
+        lambda t: hazard(jnp.array(t), energy_arr).item(),
+        0.0,
+        max_age,
+        limit=10000,
+    )
+    return result[0]
 
 
-def cumulative_survival(
+def compute_cumulative_survival(
     hazard: HazardFunction,
     *,
-    energy: float = 0.0,
+    energy: float = 10.0,
     max_age: float = 1e6,
 ) -> float:
-    status = Status(
-        age=jnp.array(0),
-        energy=jnp.array(energy),
-        is_alive=jnp.array(True),
-    )
+    """Compute cumulative survival rate using numeric integration"""
+    energy_arr = jnp.array(energy)
     result = integrate.quad(
-        lambda t: hazard.survival(status.replace(t=jnp.array(t))).item(),
+        lambda t: hazard(jnp.array(t), energy_arr).item(),
         0,
         max_age,
     )
     return result[0]
 
 
-def stable_birth_rate(
+def compute_stable_birth_rate(
     hazard: HazardFunction,
     *,
-    energy: float = 0.0,
+    energy: float = 10.0,
     max_age: float = 1e6,
 ) -> float:
-    cumsuv = cumulative_survival(hazard, energy=energy, max_age=max_age)
+    """Compute cumulative survival rate using numeric integration"""
+    cumsuv = compute_cumulative_survival(hazard, energy=energy, max_age=max_age)
     return 1.0 / cumsuv
 
 
@@ -304,16 +279,22 @@ def expected_n_children(
     hazard: HazardFunction,
     max_age: float = 1e6,
     asexual: bool = False,
-    **status_kwargs,
+    energy: float = 10.0,
 ) -> float:
-    def integrated(t: int) -> float:
-        status = Status(age=t, **status_kwargs)
+    energy_arr = jnp.array(energy)
+
+    def integrated(t: float) -> float:
+        age_arr = jnp.array(t)
         if asexual:
-            b = birth.asexual(status)
+            b = birth.asexual(age_arr, energy_arr).item()
         else:
-            b = birth.sexual(status, status)
-        h = hazard.survival(status).item()
+            b = birth.sexual(age_arr, energy_arr, age_arr, energy_arr).item()
+        h = hazard.survival(age_arr, energy_arr).item()
         return h * b
 
     result = integrate.quad(integrated, 0, max_age)
     return result[0]
+
+
+def evaluate_hazard(hf: HazardFunction):
+    assert False, "unimplemnted"

From a17cde5fe30dfc4f3fe3643ce9ee653f6e5dd287 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 24 Nov 2023 15:05:28 +0900
Subject: [PATCH 090/337] Delete old birth_and_death module

---
 src/emevo/birth_and_death/__init__.py   |   6 -
 src/emevo/birth_and_death/birth.py      | 108 --------------
 src/emevo/birth_and_death/core.py       | 152 -------------------
 src/emevo/birth_and_death/death.py      | 189 ------------------------
 src/emevo/birth_and_death/newborn.py    |  63 --------
 src/emevo/birth_and_death/population.py |  69 ---------
 6 files changed, 587 deletions(-)
 delete mode 100644 src/emevo/birth_and_death/__init__.py
 delete mode 100644 src/emevo/birth_and_death/birth.py
 delete mode 100644 src/emevo/birth_and_death/core.py
 delete mode 100644 src/emevo/birth_and_death/death.py
 delete mode 100644 src/emevo/birth_and_death/newborn.py
 delete mode 100644 src/emevo/birth_and_death/population.py

diff --git a/src/emevo/birth_and_death/__init__.py b/src/emevo/birth_and_death/__init__.py
deleted file mode 100644
index db9521cc..00000000
--- a/src/emevo/birth_and_death/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-"""Utilities for handling birth and death of agents.
-"""
-
-from . import birth, core, death, population
-from .core import AsexualReprManager, DeadBody, SexualReprManager
-from .newborn import Newborn, Oviparous, Viviparous
diff --git a/src/emevo/birth_and_death/birth.py b/src/emevo/birth_and_death/birth.py
deleted file mode 100644
index 2bf7fac8..00000000
--- a/src/emevo/birth_and_death/birth.py
+++ /dev/null
@@ -1,108 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-from typing import Protocol
-
-import numpy as np
-
-from emevo.status import Status
-
-
-class BirthFunction(Protocol):
-    def asexual(self, status: Status) -> float:
-        """Birth function b(t)"""
-        ...
-
-    def sexual(self, status_a: Status, status_b: Status) -> float:
-        """Birth function b(t)"""
-        ...
-
-
-@dataclasses.dataclass
-class Logistic(BirthFunction):
-    scale: float
-    alpha: float = 1.0
-    beta: float = 0.001
-    age_delay: float = 1000.0
-    energy_delay: float = 8.0
-
-    def _exp_age(self, age: float) -> float:
-        return np.exp(-self.beta * (age - self.age_delay))
-
-    def _exp_neg_energy(self, energy: float) -> float:
-        return np.exp(self.energy_delay - energy)
-
-    def asexual(self, status: Status) -> float:
-        exp_neg_age = self._exp_age(status.age)
-        exp_neg_energy = self._exp_neg_energy(status.energy)
-        return self.scale / (1.0 + self.alpha * (exp_neg_age + exp_neg_energy))
-
-    def sexual(self, status_a: Status, status_b: Status) -> float:
-        exp_neg_age_a = self._exp_age(status_a.age)
-        exp_neg_energy_a = self._exp_neg_energy(status_a.energy)
-        exp_neg_age_b = self._exp_age(status_b.age)
-        exp_neg_energy_b = self._exp_neg_energy(status_b.energy)
-        sum_exp = exp_neg_age_a + exp_neg_energy_a + exp_neg_age_b + exp_neg_energy_b
-        return self.scale / (1.0 + self.alpha * sum_exp)
-
-
-@dataclasses.dataclass
-class EnergyLogistic(BirthFunction):
-    """
-    Only energy is important to give birth.
-    b(t) = scale / (1.0 + α x exp(delay - e(t)))
-    """
-
-    scale: float
-    alpha: float = 1.0
-    delay: float = 8.0
-
-    def _exp_neg_energy(self, energy: float) -> float:
-        return np.exp(self.delay - energy)
-
-    def asexual(self, status: Status) -> float:
-        exp_neg_energy = self._exp_neg_energy(status.energy)
-        return self.scale / (1.0 + self.alpha * exp_neg_energy)
-
-    def sexual(self, status_a: Status, status_b: Status) -> float:
-        exp_neg_energy_a = self._exp_neg_energy(status_a.energy)
-        exp_neg_energy_b = self._exp_neg_energy(status_b.energy)
-        sum_exp = exp_neg_energy_a + exp_neg_energy_b
-        return self.scale / (1.0 + self.alpha * sum_exp)
-
-
-@dataclasses.dataclass
-class EnergyLogisticMeta(BirthFunction):
-    """
-    Only energy is important to give birth.
-    Note that all fields in metadata should have 'birth_' prefix.
-    """
-
-    scale: float
-    alpha: float = 1.0
-    delay: float = 8.0
-
-    def _exp_neg_energy(self, status: Status) -> float:
-        assert status.metadata is not None
-        energy_delay = status.metadata.get("birth_delay", self.delay)
-        return np.exp(energy_delay - status.energy)
-
-    def asexual(self, status: Status) -> float:
-        assert status.metadata is not None
-        exp_neg_energy = self._exp_neg_energy(status)
-        scale = status.metadata.get("birth_scale", self.scale)
-        alpha = status.metadata.get("birth_alpha", self.alpha)
-        return scale / (1.0 + alpha * exp_neg_energy)
-
-    def sexual(self, status_a: Status, status_b: Status) -> float:
-        assert status_a.metadata is not None and status_b.metadata is not None
-        exp_neg_energy_a = self._exp_neg_energy(status_a)
-        exp_neg_energy_b = self._exp_neg_energy(status_b)
-        sum_exp = exp_neg_energy_a + exp_neg_energy_b
-        scale_a = status_a.metadata.get("birth_scale", self.scale)
-        alpha_a = status_a.metadata.get("birth_alpha", self.alpha)
-        scale_b = status_b.metadata.get("birth_scale", self.scale)
-        alpha_b = status_b.metadata.get("birth_alpha", self.alpha)
-        scale = (scale_a + scale_b) / 2
-        alpha = (alpha_a + alpha_b) / 2
-        return scale / (1.0 + alpha * sum_exp)
diff --git a/src/emevo/birth_and_death/core.py b/src/emevo/birth_and_death/core.py
deleted file mode 100644
index c3ec78e4..00000000
--- a/src/emevo/birth_and_death/core.py
+++ /dev/null
@@ -1,152 +0,0 @@
-"""Core components of birth_and_death, including Manager
-"""
-from __future__ import annotations
-
-import dataclasses
-from typing import Callable, Generic, Iterable
-
-import numpy as np
-from typing_extensions import ParamSpec
-
-from emevo.birth_and_death.newborn import Newborn
-from emevo.body import Body, Encount
-from emevo.status import Status
-
-
-@dataclasses.dataclass(frozen=True)
-class DeadBody:
-    """Dead Body"""
-
-    body: Body
-    status: Status
-
-
-P = ParamSpec("P")
-
-
-class _BaseManager(Generic[P]):
-    """
-    Manager manages energy level, birth and death of agents.
-    Note that Manager does not manage matings.
-    """
-
-    def __init__(
-        self,
-        initial_status_fn: Callable[P, Status],
-        hazard_fn: Callable[[Status], float],
-        rng: Callable[[], float] = np.random.rand,
-    ) -> None:
-        self._initial_status_fn = initial_status_fn
-        self._hazard_fn = hazard_fn
-        self._rng = rng
-        self._statuses = {}
-        self._pending_newborns = []
-
-    def available_bodies(self) -> Iterable[Body]:
-        return self._statuses.keys()
-
-    def register(
-        self,
-        body: Body | Iterable[Body],
-        *args: P.args,
-        **kwargs: P.kwargs,
-    ) -> None:
-        if isinstance(body, Body):
-            self._statuses[body] = self._initial_status_fn(*args, **kwargs)
-        else:
-            for body_i in body:
-                self._statuses[body_i] = self._initial_status_fn(*args, **kwargs)
-
-    def step(self) -> tuple[list[DeadBody], list[Newborn]]:
-        deads, newborns = [], []
-
-        for body, status in self._statuses.items():
-            status.step()
-            if self._rng() < self._hazard_fn(status):
-                deads.append(DeadBody(body, status))
-
-        for dead in deads:
-            del self._statuses[dead.body]
-
-        for newborn in self._pending_newborns:
-            newborn.step()
-            if newborn.is_ready():
-                newborns.append(newborn)
-
-        for newborn in newborns:
-            self._pending_newborns.remove(newborn)
-
-        return deads, newborns
-
-    def update_status(self, body: Body, **updates) -> Status:
-        return self._statuses[body].update(**updates)
-
-    def energy(self, body: Body) -> float:
-        """To use with enviroment's energy_fn"""
-        return self._statuses[body].energy
-
-
-class AsexualReprManager(_BaseManager):
-    def __init__(
-        self,
-        initial_status_fn: Callable[P, Status],
-        hazard_fn: Callable[[Status], float],
-        birth_fn: Callable[[Status], float],
-        produce_fn: Callable[[Status, Body], Newborn],
-        rng: Callable[[], float] = np.random.rand,
-    ) -> None:
-        super().__init__(initial_status_fn, hazard_fn, rng)
-        self._birth_fn = birth_fn
-        self._produce_fn = produce_fn
-
-    def _try_reproduce(self, body: Body) -> bool:
-        success_prob = self._birth_fn(self._statuses[body])
-        if self._rng() < success_prob:
-            newborn = self._produce_fn(self._statuses[body], body)
-            self._pending_newborns.append(newborn)
-            return True
-        else:
-            return False
-
-    def reproduce(self, body: Body | Iterable[Body]) -> list[Body]:
-        """
-        Try asexual reproducation from a body or an iterator over bodies.
-        Return a list of bodies that reproduced themselves.
-        """
-        if isinstance(body, Body):
-            bodies = [body]
-        else:
-            bodies = body
-        return [body for body in bodies if self._try_reproduce(body)]
-
-
-class SexualReprManager(_BaseManager):
-    def __init__(
-        self,
-        initial_status_fn: Callable[P, Status],
-        hazard_fn: Callable[[Status], float],
-        birth_fn: Callable[[Status, Status], float],
-        produce_fn: Callable[[Status, Status, Encount], Newborn],
-        rng: Callable[[], float] = np.random.rand,
-    ) -> None:
-        super().__init__(initial_status_fn, hazard_fn, rng)
-        self._birth_fn = birth_fn
-        self._produce_fn = produce_fn
-
-    def _try_reproduce(self, encount: Encount) -> bool:
-        s_a, s_b = map(lambda body: self._statuses[body], encount)
-        success_prob = self._birth_fn(s_a, s_b)
-        if self._rng() < success_prob:
-            newborn = self._produce_fn(s_a, s_b, encount)
-            self._pending_newborns.append(newborn)
-            return True
-        else:
-            return False
-
-    def reproduce(self, encount: Encount | Iterable[Encount]) -> list[Encount]:
-        """Try asexual reproducation from an encount or an iterator over encounts."""
-        if isinstance(encount, Encount):
-            encounts = [encount]
-        else:
-            encounts = encount
-        return [encount for encount in encounts if self._try_reproduce(encount)]
diff --git a/src/emevo/birth_and_death/death.py b/src/emevo/birth_and_death/death.py
deleted file mode 100644
index 587a785a..00000000
--- a/src/emevo/birth_and_death/death.py
+++ /dev/null
@@ -1,189 +0,0 @@
-""" Collection of hazard functions
-"""
-import dataclasses
-from typing import Protocol
-
-import numpy as np
-
-from emevo.status import Status
-
-
-class HazardFunction(Protocol):
-    def __call__(self, status: Status) -> float:
-        """Hazard function h(t)"""
-        ...
-
-    def cumulative(self, status: Status) -> float:
-        """Cumulative hazard function H(t) = ∫h(t)"""
-        ...
-
-    def survival(self, status: Status) -> float:
-        """Survival Rate S(t) = exp(-H(t))"""
-        ...
-
-
-@dataclasses.dataclass
-class Deterministic(HazardFunction):
-    """
-    A deterministic hazard function where an agent dies when
-    - its energy level is lower than the energy thershold or
-    - its age is older than the the age thershold
-    """
-
-    energy_threshold: float
-    age_threshold: float
-
-    def __call__(self, status: Status) -> float:
-        if status.energy < self.energy_threshold or self.age_threshold < status.age:
-            return 1.0
-        else:
-            return 0.0
-
-    def cumulative(self, status: Status) -> float:
-        return self(status)
-
-    def survival(self, status: Status) -> float:
-        if status.energy < self.energy_threshold or self.age_threshold < status.age:
-            return 0.0
-        else:
-            return 1.0
-
-
-@dataclasses.dataclass
-class Constant(HazardFunction):
-    """
-    Hazard with constant death rate.
-    Energy
-    α = α_const + α_energy * exp(-γenergy)
-    h(t) = α
-    H(t) = αt
-    S(t) = exp(-αt)
-    """
-
-    alpha_const: float = 1e-5
-    alpha_energy: float = 1e-6
-    gamma: float = 1.0
-
-    def _alpha(self, status: Status) -> float:
-        alpha_energy = self.alpha_energy * np.exp(-self.gamma * status.energy)
-        return self.alpha_const + alpha_energy
-
-    def __call__(self, status: Status) -> float:
-        return self._alpha(status)
-
-    def cumulative(self, status: Status) -> float:
-        return self(status) * status.age
-
-    def survival(self, status: Status) -> float:
-        return np.exp(-self.cumulative(status))
-
-
-@dataclasses.dataclass
-class EnergyLogistic(HazardFunction):
-    """
-    Hazard with death rate that only depends on energy.
-    h(e) = h_max (1 - 1 / (1 + αexp(e0 - e))
-    """
-
-    alpha: float = 1.0
-    hmax: float = 1.0
-    e0: float = 3.0
-
-    def _energy_death_rate(self, energy: float) -> float:
-        exp_neg_energy = self.alpha * np.exp(self.e0 - energy)
-        return self.hmax * (1.0 - 1.0 / (1.0 + self.alpha * exp_neg_energy))
-
-    def __call__(self, status: Status) -> float:
-        return self._energy_death_rate(status.energy)
-
-    def cumulative(self, status: Status) -> float:
-        return self._energy_death_rate(status.energy) * status.age
-
-    def survival(self, status: Status) -> float:
-        return np.exp(-self.cumulative(status))
-
-
-@dataclasses.dataclass
-class Gompertz(Constant):
-    """
-    Hazard with exponentially increasing death rate.
-    α = α_const + α_energy * exp(-γenergy)
-    h(t) = α exp(βt)
-    H(t) = α/β exp(βt)
-    S(t) = exp(-H(t))
-    """
-
-    beta: float = 1e-5
-
-    def __call__(self, status: Status) -> float:
-        return self._alpha(status) * np.exp(self.beta * status.age)
-
-    def cumulative(self, status: Status) -> float:
-        alpha = self._alpha(status)
-        ht = alpha / self.beta * np.exp(self.beta * status.age)
-        h0 = alpha / self.beta
-        return ht - h0
-
-    def survival(self, status: Status) -> float:
-        return np.exp(-self.cumulative(status))
-
-
-@dataclasses.dataclass
-class SeparatedGompertz(EnergyLogistic):
-    """
-    Hazard with exponentially increasing death rate.
-    h(e) = h_max (1 - 1 / (1 + αexp(e0 - e))
-    h(t) = αexp(βt) + h(e)
-    H(t) = α/β exp(βt) + h(e)t
-    S(t) = exp(-H(t))
-    """
-
-    alpha_age: float = 1e-6
-    beta: float = 1e-5
-
-    def __call__(self, status: Status) -> float:
-        age = self.alpha_age * np.exp(self.beta * status.age)
-        energy = self._energy_death_rate(status.energy)
-        return age + energy
-
-    def cumulative(self, status: Status) -> float:
-        energy = self._energy_death_rate(status.energy) * status.age
-        ht = energy + self.alpha_age / self.beta * np.exp(self.beta * status.age)
-        h0 = self.alpha_age / self.beta
-        return ht - h0
-
-    def survival(self, status: Status) -> float:
-        return np.exp(-self.cumulative(status))
-
-
-@dataclasses.dataclass
-class SimplifiedGompertz(HazardFunction):
-    """
-    Similar to SeparatedGompertz, but with less parameters.
-    h(e) = αexp(-βe)
-    h(t) = αexp(βt) + h(e)
-    H(t) = α/β exp(βt) + h(e)t
-    S(t) = exp(-H(t))
-    """
-
-    alpha_e: float = 0.01
-    alpha_t: float = 1e-4
-    beta_e: float = 0.8
-    beta_t: float = 1e-5
-
-    def _he(self, energy: float) -> float:
-        return self.alpha_e * np.exp(-self.beta_e * energy)
-
-    def __call__(self, status: Status) -> float:
-        age = self.alpha_t * np.exp(self.beta_t * status.age)
-        energy = self._he(status.energy)
-        return age + energy
-
-    def cumulative(self, status: Status) -> float:
-        energy = self._he(status.energy) * status.age
-        ht = energy + self.alpha_t / self.beta_t * np.exp(self.beta_t * status.age)
-        h0 = self.alpha_t / self.beta_t
-        return ht - h0
-
-    def survival(self, status: Status) -> float:
-        return np.exp(-self.cumulative(status))
diff --git a/src/emevo/birth_and_death/newborn.py b/src/emevo/birth_and_death/newborn.py
deleted file mode 100644
index f177146c..00000000
--- a/src/emevo/birth_and_death/newborn.py
+++ /dev/null
@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-import abc
-from typing import Any, Generic
-
-from emevo.body import Body
-from emevo.env import LOC
-from emevo.status import Status
-
-
-class Newborn(abc.ABC, Generic[LOC]):
-    """A class that contains information of birth type."""
-
-    def __init__(
-        self,
-        parent: Body,
-        parental_status: Status | tuple[Status, Status],
-        time_to_birth: int,
-        info: Any = None,
-    ) -> None:
-        self.parent = parent
-        self.parental_status = parental_status
-        self.info = info
-        self.time_to_birth = time_to_birth
-
-    def is_ready(self) -> bool:
-        """Return if the newborn is ready to be born or not."""
-        return self.time_to_birth == 0
-
-    @abc.abstractmethod
-    def location(self) -> LOC:
-        """Notify the newborn that the timestep has moved on."""
-        pass
-
-    def step(self) -> None:
-        """Notify the newborn that the timestep has moved on."""
-        if self.time_to_birth == 0:
-            raise RuntimeError("Newborn.step is called when it's ready")
-        self.time_to_birth -= 1
-
-
-class Oviparous(Newborn[LOC]):
-    """A newborn stays in an egg for a while and will be born."""
-
-    def __init__(
-        self,
-        parent: Body,
-        parental_status: Status | tuple[Status, Status],
-        time_to_birth: int,
-        info: Any = None,
-    ) -> None:
-        super().__init__(parent, parental_status, time_to_birth, info=info)
-        self._location = parent.location()
-
-    def location(self) -> LOC:
-        return self._location
-
-
-class Viviparous(Newborn[LOC]):
-    """A newborn stays in a parent's body for a while and will be born."""
-
-    def location(self) -> LOC:
-        return self.parent.location()
diff --git a/src/emevo/birth_and_death/population.py b/src/emevo/birth_and_death/population.py
deleted file mode 100644
index 460c7197..00000000
--- a/src/emevo/birth_and_death/population.py
+++ /dev/null
@@ -1,69 +0,0 @@
-""" Compute population statistics based on birth and hazard functions.
-"""
-
-
-from scipy import integrate
-
-from emevo.birth_and_death.birth import BirthFunction
-from emevo.birth_and_death.death import HazardFunction
-from emevo.status import Status
-
-
-def cumulative_hazard(
-    hazard: HazardFunction,
-    *,
-    energy: float = 0.0,
-    max_age: float = 1e6,
-) -> float:
-    result = integrate.quad(
-        lambda t: hazard(Status(age=t, energy=energy)),
-        0.0,
-        max_age,
-        limit=10000,
-    )
-    return result[0]
-
-
-def cumulative_survival(
-    hazard: HazardFunction,
-    *,
-    energy: float = 0.0,
-    max_age: float = 1e6,
-) -> float:
-    result = integrate.quad(
-        lambda t: hazard.survival(Status(age=t, energy=energy)),
-        0,
-        max_age,
-    )
-    return result[0]
-
-
-def stable_birth_rate(
-    hazard: HazardFunction,
-    *,
-    energy: float = 0.0,
-    max_age: float = 1e6,
-) -> float:
-    cumsuv = cumulative_survival(hazard, energy=energy, max_age=max_age)
-    return 1.0 / cumsuv
-
-
-def expected_n_children(
-    *,
-    birth: BirthFunction,
-    hazard: HazardFunction,
-    max_age: float = 1e6,
-    asexual: bool = False,
-    **status_kwargs,
-) -> float:
-    def integrated(t: int) -> float:
-        status = Status(age=t, **status_kwargs)
-        if asexual:
-            b = birth.asexual(status)
-        else:
-            b = birth.sexual(status, status)
-        h = hazard.survival(status)
-        return h * b
-
-    result = integrate.quad(integrated, 0, max_age)
-    return result[0]

From 3ea6f86ccc95ee24e41bb9dd2a0dd1cfd8fac2e0 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 24 Nov 2023 16:44:03 +0900
Subject: [PATCH 091/337] Timestep now returns energy_delta

---
 src/emevo/birth_and_death.py              |  6 +++++-
 src/emevo/env.py                          |  1 +
 src/emevo/environments/circle_foraging.py | 26 +++++++++++++++++------
 src/emevo/status.py                       |  5 -----
 tests/test_placement.py                   |  2 +-
 5 files changed, 26 insertions(+), 14 deletions(-)

diff --git a/src/emevo/birth_and_death.py b/src/emevo/birth_and_death.py
index 1379a6d8..3280c3e2 100644
--- a/src/emevo/birth_and_death.py
+++ b/src/emevo/birth_and_death.py
@@ -296,5 +296,9 @@ def integrated(t: float) -> float:
     return result[0]
 
 
-def evaluate_hazard(hf: HazardFunction):
+def evaluate_hazard(
+    hf: HazardFunction,
+    age_from: jax.Array,
+    age_to: jax.Array,
+):
     assert False, "unimplemnted"
diff --git a/src/emevo/env.py b/src/emevo/env.py
index 7830f9ac..01111a5f 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -94,6 +94,7 @@ def as_array(self) -> jax.Array:
 class TimeStep(Generic[OBS]):
     encount: jax.Array | None
     obs: OBS
+    energy_delta: jax.Array
     info: dict[str, Any] = dataclasses.field(default_factory=dict)
 
 
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 345764d1..32e102f9 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -321,6 +321,7 @@ def __init__(
         angular_damping: float = 0.6,
         max_force: float = 40.0,
         min_force: float = -20.0,
+        force_energy_consumption: float = 0.01 / 40.0,
         n_velocity_iter: int = 6,
         n_position_iter: int = 2,
         n_physics_iter: int = 5,
@@ -350,6 +351,8 @@ def __init__(
         self._agent_loc_fn, self._initial_agentloc_state = self._make_agent_loc_fn(
             agent_loc_fn
         )
+        # Energy consumption
+        self._force_energy_consumption = force_energy_consumption
         # Initial numbers
         assert n_max_agents > n_initial_agents
         assert n_max_foods > self._food_num_fn.initial
@@ -522,10 +525,10 @@ def step(
     ) -> tuple[CFState, TimeStep[CFObs]]:
         # Add force
         act = jax.vmap(self.act_space.clip)(jnp.array(action))
-        f1 = jax.lax.slice_in_dim(act, 0, 1, axis=-1)
-        f2 = jax.lax.slice_in_dim(act, 1, 2, axis=-1)
-        f1 = jnp.concatenate((jnp.zeros_like(f1), f1), axis=1)
-        f2 = jnp.concatenate((jnp.zeros_like(f2), f2), axis=1)
+        f1_raw = jax.lax.slice_in_dim(act, 0, 1, axis=-1)
+        f2_raw = jax.lax.slice_in_dim(act, 1, 2, axis=-1)
+        f1 = jnp.concatenate((jnp.zeros_like(f1_raw), f1_raw), axis=1)
+        f2 = jnp.concatenate((jnp.zeros_like(f2_raw), f2_raw), axis=1)
         circle = state.physics.circle
         circle = circle.apply_force_local(self._act_p1, f1)
         circle = circle.apply_force_local(self._act_p2, f2)
@@ -542,8 +545,10 @@ def step(
         c2c = self._physics.get_contact_mat("circle", "circle", contacts)
         c2sc = self._physics.get_contact_mat("circle", "static_circle", contacts)
         seg2c = self._physics.get_contact_mat("segment", "circle", contacts)
+        # This is also used in computing energy_delta
+        food_collision = jnp.max(c2sc, axis=1)
         collision = jnp.stack(
-            (jnp.max(c2c, axis=1), jnp.max(c2sc, axis=1), jnp.max(seg2c, axis=0)),
+            (jnp.max(c2c, axis=1), food_collision, jnp.max(seg2c, axis=0)),
             axis=1,
         )
         # Gather sensor obs
@@ -555,7 +560,10 @@ def step(
             velocity=stated.circle.v.xy,
             angular_velocity=stated.circle.v.angle,
         )
-        timestep = TimeStep(encount=c2c, obs=obs)
+        # energy_delta = food - coef * force
+        force_sum = jnp.abs(f1_raw) + jnp.abs(f2_raw)
+        energy_delta = food_collision - self._force_energy_consumption * force_sum
+        timestep = TimeStep(encount=c2c, obs=obs, energy_delta=energy_delta)
         # Remove and reproduce foods
         key, food_key = jax.random.split(state.key)
         stated, food_num, food_loc = self._remove_and_reproduce_foods(
@@ -636,7 +644,11 @@ def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
             velocity=physics.circle.v.xy,
             angular_velocity=physics.circle.v.angle,
         )
-        timestep = TimeStep(encount=None, obs=obs)
+        timestep = TimeStep(
+            encount=None,
+            obs=obs,
+            energy_delta=jnp.zeros(self._n_max_agents),
+        )
         return state, timestep
 
     def _initialize_physics_state(
diff --git a/src/emevo/status.py b/src/emevo/status.py
index d1e2459f..d397d0c3 100644
--- a/src/emevo/status.py
+++ b/src/emevo/status.py
@@ -23,11 +23,6 @@ def step(self) -> Self:
         """Get older."""
         return self.replace(age=self.age + 1)
 
-    def share(self, ratio: float) -> tuple[Self, jax.Array]:
-        """Share some portion of energy."""
-        shared = self.energy * ratio
-        return self.update(energy_delta=-shared), shared
-
     def update(self, *, energy_delta: jax.Array) -> Self:
         """Update energy."""
         energy = self.energy + jnp.where(
diff --git a/tests/test_placement.py b/tests/test_placement.py
index 1cb81bde..c170ff79 100644
--- a/tests/test_placement.py
+++ b/tests/test_placement.py
@@ -26,7 +26,7 @@ def get_space_and_more() -> tuple[Space, StateDict, CircleCoordinate]:
         linear_damping=0.9,
         angular_damping=0.9,
         n_velocity_iter=4,
-        n_posiiton_iter=2,
+        n_position_iter=2,
         n_max_agents=N_MAX_AGENTS,
         n_max_foods=N_MAX_FOODS,
         agent_radius=AGENT_RADIUS,

From c10a9b32bc16a4d3c29c535dadb5f9c1d127f2be Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 24 Nov 2023 17:42:56 +0900
Subject: [PATCH 092/337] Fix encount test

---
 tests/test_observe.py | 43 +++++++++++++++++++++----------------------
 1 file changed, 21 insertions(+), 22 deletions(-)

diff --git a/tests/test_observe.py b/tests/test_observe.py
index 4aa424c2..1c4762ba 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -135,38 +135,37 @@ def test_encount_and_collision(key: chex.PRNGKey) -> None:
     # O x 2→ ←4
     env, state, _ = reset_env(key)
     step = jax.jit(env.step)
-    act1 = jnp.zeros((10, 2)).at[2, 0].set(5.0).at[3, 0].set(-5.0).at[4, 0].set(-5.0)
+    act1 = jnp.zeros((10, 2)).at[2, 0].set(20).at[3:5, 1].set(20)
     while True:
         state, ts = step(state, act1)
         assert jnp.all(jnp.logical_not(ts.encount))
-        if state.physics.circle.p.angle[4] >= jnp.pi * 0.4:
+        if state.physics.circle.p.angle[4] >= jnp.pi * 0.45:
             break
-    act2 = jnp.zeros((10, 2)).at[2, 1].set(10.0).at[3, 1].set(10.0).at[4, 1].set(10.0)
+
+    act2 = jnp.zeros((10, 2)).at[2:5].set(20.0)
+    p2p4_ok, p3_ok = False, False
     for i in range(100):
+        p2 = state.physics.circle.p.xy[2]
+        p3 = state.physics.circle.p.xy[3]
+        p4 = state.physics.circle.p.xy[4]
         state, ts = step(state, act2)
-        p = state.physics.circle.p.xy[3]
-        if jnp.linalg.norm(p - jnp.array([80.0, 90.0])) <= AGENT_RADIUS + FOOD_RADIUS:
-            assert bool(ts.obs.collision[3, 1]), p
+        if not p2p4_ok and jnp.linalg.norm(p2 - p4) <= 2 * AGENT_RADIUS:
+            assert bool(ts.encount[2, 4]), (p2, p3, p4)
+            assert bool(ts.encount[4, 2]), (p2, p3, p4)
+            assert bool(ts.obs.collision[2, 0]), (p2, p3, p4)
+            assert bool(ts.obs.collision[4, 0]), (p2, p3, p4)
+            p2p4_ok = True
+
+        p3_to_food = jnp.linalg.norm(p3 - jnp.array([80.0, 90.0]))
+        if not p3_ok and p3_to_food <= AGENT_RADIUS + FOOD_RADIUS:
+            assert bool(ts.obs.collision[3, 1]), (p2, p3, p4)
+            p3_ok = True
+
+        if p2p4_ok and p3_ok:
             break
-        else:
-            assert not jnp.any(ts.obs.collision), ts.obs.collision[:5]
 
     assert i < 99
 
-    for i in range(200):
-        state, ts = step(state, act2)
-        p1 = state.physics.circle.p.xy[2]
-        p2 = state.physics.circle.p.xy[4]
-        if jnp.linalg.norm(p1 - p2) <= 2 * AGENT_RADIUS:
-            assert bool(ts.encount[2, 4])
-            assert bool(ts.encount[4, 2])
-            assert bool(ts.obs.collision[2, 0])
-            assert bool(ts.obs.collision[4, 0])
-            break
-        else:
-            assert jnp.all(jnp.logical_not(ts.encount)), f"P1: {p1}, P2: {p2}"
-    assert i < 199
-
 
 def test_asarray(key: chex.PRNGKey) -> None:
     env, state, timestep = reset_env(key)

From 31b77f5f5fafc85d7fa6fb822c0a6f7739ea75ab Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 24 Nov 2023 19:21:17 +0900
Subject: [PATCH 093/337] Simplify hazard and birth functions

---
 src/emevo/birth_and_death.py  | 103 ++++++++-------------------
 src/emevo/genetic_ops.py      | 129 ++++++++++++++++++++++++++++++++++
 tests/test_birth_and_death.py |   8 +++
 3 files changed, 167 insertions(+), 73 deletions(-)
 create mode 100644 src/emevo/genetic_ops.py
 create mode 100644 tests/test_birth_and_death.py

diff --git a/src/emevo/birth_and_death.py b/src/emevo/birth_and_death.py
index 3280c3e2..733c8f2c 100644
--- a/src/emevo/birth_and_death.py
+++ b/src/emevo/birth_and_death.py
@@ -72,10 +72,10 @@ def _alpha(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         return self.alpha_const + alpha_energy
 
     def __call__(self, age: jax.Array, energy: jax.Array) -> jax.Array:
-        return self._alpha(status)
+        return self._alpha(age, energy)
 
     def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
-        return self(status) * age
+        return self(age, energy) * age
 
 
 @dataclasses.dataclass
@@ -113,10 +113,10 @@ class GompertzHazard(ConstantHazard):
     beta: float = 1e-5
 
     def __call__(self, age: jax.Array, energy: jax.Array) -> jax.Array:
-        return self._alpha(status) * jnp.exp(self.beta * age)
+        return self._alpha(age, energy) * jnp.exp(self.beta * age)
 
     def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
-        alpha = self._alpha(status)
+        alpha = self._alpha(age, energy)
         ht = alpha / self.beta * jnp.exp(self.beta * age)
         h0 = alpha / self.beta
         return ht - h0
@@ -148,55 +148,15 @@ def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
 
 
 class BirthFunction(Protocol):
-    def asexual(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+    def __call__(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         """Birth function b(t)"""
         ...
 
-    def sexual(
-        self,
-        age_a: jax.Array,
-        energy_a: jax.Array,
-        age_b: jax.Array,
-        energy_b: jax.Array,
-    ) -> jax.Array:
-        """Birth function b(t)"""
+    def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        """Cumulative birth function B(t) = ∫b(t)"""
         ...
 
 
-@dataclasses.dataclass
-class LogisticBirth(BirthFunction):
-    scale: float
-    alpha: float = 1.0
-    beta: float = 0.001
-    age_delay: float = 1000.0
-    energy_delay: float = 8.0
-
-    def _exp_age(self, age: jax.Array) -> jax.Array:
-        return jnp.exp(-self.beta * (age - self.age_delay))
-
-    def _exp_neg_energy(self, energy: jax.Array) -> jax.Array:
-        return jnp.exp(self.energy_delay - energy)
-
-    def asexual(self, age: jax.Array, energy: jax.Array) -> jax.Array:
-        exp_neg_age = self._exp_age(age)
-        exp_neg_energy = self._exp_neg_energy(energy)
-        return self.scale / (1.0 + self.alpha * (exp_neg_age + exp_neg_energy))
-
-    def sexual(
-        self,
-        age_a: jax.Array,
-        energy_a: jax.Array,
-        age_b: jax.Array,
-        energy_b: jax.Array,
-    ) -> jax.Array:
-        exp_neg_age_a = self._exp_age(age_a)
-        exp_neg_energy_a = self._exp_neg_energy(energy_a)
-        exp_neg_age_b = self._exp_age(age_b)
-        exp_neg_energy_b = self._exp_neg_energy(energy_b)
-        sum_exp = exp_neg_age_a + exp_neg_energy_a + exp_neg_age_b + exp_neg_energy_b
-        return self.scale / (1.0 + self.alpha * sum_exp)
-
-
 @dataclasses.dataclass
 class EnergyLogisticBirth(BirthFunction):
     """
@@ -208,25 +168,14 @@ class EnergyLogisticBirth(BirthFunction):
     alpha: float = 1.0
     delay: float = 8.0
 
-    def _exp_neg_energy(self, energy: jax.Array) -> jax.Array:
-        return jnp.exp(self.delay - energy)
-
-    def asexual(self, _age: jax.Array, energy: jax.Array) -> jax.Array:
-        exp_neg_energy = self._exp_neg_energy(energy)
+    def __call__(self, _age: jax.Array, energy: jax.Array) -> jax.Array:
+        del _age
+        exp_neg_energy = jnp.exp(self.delay - energy)
         return self.scale / (1.0 + self.alpha * exp_neg_energy)
 
-    def sexual(
-        self,
-        _age_a: jax.Array,
-        energy_a: jax.Array,
-        _age_b: jax.Array,
-        energy_b: jax.Array,
-    ) -> jax.Array:
-        del _age_a, _age_b
-        exp_neg_energy_a = self._exp_neg_energy(energy_a)
-        exp_neg_energy_b = self._exp_neg_energy(energy_b)
-        sum_exp = exp_neg_energy_a + exp_neg_energy_b
-        return self.scale / (1.0 + self.alpha * sum_exp)
+    def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        """Birth function b(t)"""
+        return age * self(age, energy)
 
 
 def compute_cumulative_hazard(
@@ -278,17 +227,13 @@ def expected_n_children(
     birth: BirthFunction,
     hazard: HazardFunction,
     max_age: float = 1e6,
-    asexual: bool = False,
     energy: float = 10.0,
 ) -> float:
     energy_arr = jnp.array(energy)
 
     def integrated(t: float) -> float:
         age_arr = jnp.array(t)
-        if asexual:
-            b = birth.asexual(age_arr, energy_arr).item()
-        else:
-            b = birth.sexual(age_arr, energy_arr, age_arr, energy_arr).item()
+        b = birth(age_arr, energy_arr).item()
         h = hazard.survival(age_arr, energy_arr).item()
         return h * b
 
@@ -298,7 +243,19 @@ def integrated(t: float) -> float:
 
 def evaluate_hazard(
     hf: HazardFunction,
-    age_from: jax.Array,
-    age_to: jax.Array,
-):
-    assert False, "unimplemnted"
+    age_from: jax.Array,  # (M,)
+    age_to: jax.Array,  # (M,)
+    energies: jax.Array,  # (N, M)
+) -> jax.Array:
+    ages = jnp.linspace(age_from, age_to, energies.shape[0])
+    return jnp.sum(jax.vmap(hf)(ages, energies), axis=0)
+
+
+def evaluate_birth(
+    bf: BirthFunction,
+    age_from: jax.Array,  # (M,)
+    age_to: jax.Array,  # (M,)
+    energies: jax.Array,  # (N, M)
+) -> jax.Array:
+    ages = jnp.linspace(age_from, age_to, energies.shape[0])
+    return jnp.sum(jax.vmap(bf)(ages, energies), axis=0)
diff --git a/src/emevo/genetic_ops.py b/src/emevo/genetic_ops.py
new file mode 100644
index 00000000..999bedf0
--- /dev/null
+++ b/src/emevo/genetic_ops.py
@@ -0,0 +1,129 @@
+""" Genetics operations for any pytree."""
+
+from __future__ import annotations
+
+import abc
+import dataclasses
+from typing import cast
+
+import chex
+import jax
+import jax.numpy as jnp
+
+
+class Crossover(abc.ABC):
+    @abc.abstractmethod
+    def _select(
+        self,
+        prng_key: chex.PRNGKey,
+        array1: jax.Array,
+        array2: jax.Array,
+    ) -> jax.Array:
+        pass
+
+    def __call__(
+        self,
+        prng_key: chex.PRNGKey,
+        params_a: chex.ArrayTree,
+        params_b: chex.ArrayTree,
+    ) -> chex.ArrayTree:
+        leaves, treedef = jax.tree_util.tree_flatten(params_a)
+        prng_keys = jax.random.split(prng_key, len(leaves))
+        result = jax.tree_map(
+            self._select,
+            treedef.unflatten(prng_keys),
+            params_a,
+            params_b,
+        )
+        return result
+
+
+class Mutation(abc.ABC):
+    @abc.abstractmethod
+    def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
+        pass
+
+    def __call__(
+        self,
+        prng_key: chex.PRNGKey,
+        params: chex.ArrayTree,
+    ) -> chex.PRNGKey:
+        leaves, treedef = jax.tree_util.tree_flatten(params)
+        prng_keys = jax.random.split(prng_key, len(leaves))
+        result = jax.tree_map(self._add_noise, treedef.unflatten(prng_keys), params)
+        return result
+
+
+@dataclasses.dataclass(frozen=True)
+class UniformCrossover(Crossover):
+    bias: float
+
+    def __post_init__(self) -> None:
+        assert self.bias >= 0.0 and self.bias <= 0.5
+
+    def _select(
+        self,
+        prng_key: chex.PRNGKey,
+        array1: jax.Array,
+        array2: jax.Array,
+    ) -> jax.Array:
+        flags = jax.random.bernoulli(
+            prng_key,
+            p=self.bias + 0.5,
+            shape=array1.shape,
+        )
+        return cast(jax.Array, jnp.where(flags, array1, array2))
+
+
+@dataclasses.dataclass(frozen=True)
+class CrossoverAndMutation(Crossover):
+    crossover: Crossover
+    mutation: Mutation
+
+    def _select(
+        self,
+        prng_key: chex.PRNGKey,
+        array1: jax.Array,
+        array2: jax.Array,
+    ) -> jax.Array:
+        key1, key2 = jax.random.split(prng_key)
+        selected = self.crossover._select(key1, array1, array2)
+        return self.mutation._add_noise(key2, selected)
+
+
+@dataclasses.dataclass(frozen=True)
+class BernoulliMixtureMutation(Mutation):
+    mutation_prob: float
+    mutator: Mutation
+
+    def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
+        key1, key2 = jax.random.split(prng_key)
+        noise_added = self.mutator._add_noise(key1, array)
+        is_mutated = jax.random.bernoulli(
+            key2,
+            self.mutation_prob,
+            shape=array.shape,
+        )
+        return cast(jax.Array, jnp.where(is_mutated, noise_added, array))
+
+
+@dataclasses.dataclass(frozen=True)
+class GaussianMutation(Mutation):
+    std_dev: float
+
+    def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
+        std_normal = jax.random.normal(prng_key, shape=array.shape)
+        return array + std_normal * self.std_dev
+
+
+@dataclasses.dataclass(frozen=True)
+class UniformMutation(Mutation):
+    max_noise: float
+
+    def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
+        uniform = jax.random.uniform(
+            prng_key,
+            shape=array.shape,
+            maxval=self.max_noise * 2,
+        )
+        return array + uniform - self.max_noise
diff --git a/tests/test_birth_and_death.py b/tests/test_birth_and_death.py
new file mode 100644
index 00000000..3111cf79
--- /dev/null
+++ b/tests/test_birth_and_death.py
@@ -0,0 +1,8 @@
+import jax.numpy as jnp
+import pytest
+
+from emevo.status import init_status
+
+
+def test_det_hazard():
+    pass

From 8d22f8635282989ecd8153b4703d1126782e8be1 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 27 Nov 2023 16:15:56 +0900
Subject: [PATCH 094/337] test_birth_and_death

---
 src/emevo/birth_and_death.py  |  40 +++--------
 tests/test_birth_and_death.py | 127 ++++++++++++++++++++++++++++++++--
 2 files changed, 133 insertions(+), 34 deletions(-)

diff --git a/src/emevo/birth_and_death.py b/src/emevo/birth_and_death.py
index 733c8f2c..dbddc36b 100644
--- a/src/emevo/birth_and_death.py
+++ b/src/emevo/birth_and_death.py
@@ -67,7 +67,8 @@ class ConstantHazard(HazardFunction):
     alpha_energy: float = 1e-6
     gamma: float = 1.0
 
-    def _alpha(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+    def _alpha(self, _age: jax.Array, energy: jax.Array) -> jax.Array:
+        del _age
         alpha_energy = self.alpha_energy * jnp.exp(-self.gamma * energy)
         return self.alpha_const + alpha_energy
 
@@ -86,14 +87,14 @@ class EnergyLogisticHazard(HazardFunction):
     """
 
     alpha: float = 1.0
-    hmax: float = 1.0
+    scale: float = 1.0
     e0: float = 3.0
 
     def _energy_death_rate(self, energy: jax.Array) -> jax.Array:
-        exp_neg_energy = self.alpha * jnp.exp(self.e0 - energy)
-        return self.hmax * (1.0 - 1.0 / (1.0 + self.alpha * exp_neg_energy))
+        return self.scale * (1.0 - 1.0 / (1.0 + self.alpha * jnp.exp(self.e0 - energy)))
 
-    def __call__(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+    def __call__(self, _age: jax.Array, energy: jax.Array) -> jax.Array:
+        del _age
         return self._energy_death_rate(energy)
 
     def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
@@ -123,7 +124,7 @@ def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
 
 
 @dataclasses.dataclass
-class ELGompertz(EnergyLogisticHazard):
+class ELGompertzHazard(EnergyLogisticHazard):
     """
     Exponentially increasing with time + EnergyLogistic
     h(e) = h_max (1 - 1 / (1 + αexp(e0 - e))
@@ -164,14 +165,13 @@ class EnergyLogisticBirth(BirthFunction):
     b(t) = scale / (1.0 + α x exp(delay - e(t)))
     """
 
-    scale: float
     alpha: float = 1.0
-    delay: float = 8.0
+    scale: float = 0.1
+    e0: float = 8.0
 
     def __call__(self, _age: jax.Array, energy: jax.Array) -> jax.Array:
         del _age
-        exp_neg_energy = jnp.exp(self.delay - energy)
-        return self.scale / (1.0 + self.alpha * exp_neg_energy)
+        return self.scale / (1.0 + self.alpha * jnp.exp(self.e0 - energy))
 
     def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         """Birth function b(t)"""
@@ -239,23 +239,3 @@ def integrated(t: float) -> float:
 
     result = integrate.quad(integrated, 0, max_age)
     return result[0]
-
-
-def evaluate_hazard(
-    hf: HazardFunction,
-    age_from: jax.Array,  # (M,)
-    age_to: jax.Array,  # (M,)
-    energies: jax.Array,  # (N, M)
-) -> jax.Array:
-    ages = jnp.linspace(age_from, age_to, energies.shape[0])
-    return jnp.sum(jax.vmap(hf)(ages, energies), axis=0)
-
-
-def evaluate_birth(
-    bf: BirthFunction,
-    age_from: jax.Array,  # (M,)
-    age_to: jax.Array,  # (M,)
-    energies: jax.Array,  # (N, M)
-) -> jax.Array:
-    ages = jnp.linspace(age_from, age_to, energies.shape[0])
-    return jnp.sum(jax.vmap(bf)(ages, energies), axis=0)
diff --git a/tests/test_birth_and_death.py b/tests/test_birth_and_death.py
index 3111cf79..42e7d317 100644
--- a/tests/test_birth_and_death.py
+++ b/tests/test_birth_and_death.py
@@ -1,8 +1,127 @@
+import chex
 import jax.numpy as jnp
-import pytest
 
-from emevo.status import init_status
+import emevo.birth_and_death as bd
 
 
-def test_det_hazard():
-    pass
+def test_det_hazard() -> None:
+    hf = bd.DeterministicHazard(10.0, 100.0)
+    age = jnp.array([10.0, 110.0, 10.0, 110.0])
+    energy = jnp.array([0.0, 0.0, 20.0, 20.0])
+    hazard = hf(age, energy)
+    chex.assert_trees_all_close(hazard, jnp.array([1.0, 1.0, 0.0, 1.0]))
+
+
+def test_constant_hazard() -> None:
+    hf = bd.ConstantHazard(alpha_const=1e-5, alpha_energy=1e-6, gamma=1.0)
+    age = jnp.array([10.0, 110.0, 10.0, 110.0])
+    energy = jnp.array([0.0, 0.0, 20.0, 20.0])
+    hazard = hf(age, energy)
+    chex.assert_trees_all_close(
+        hazard,
+        jnp.array(
+            [
+                1e-5 + 1e-6 * jnp.exp(0.0),
+                1e-5 + 1e-6 * jnp.exp(0.0),
+                1e-5 + 1e-6 * jnp.exp(-20.0),
+                1e-5 + 1e-6 * jnp.exp(-20.0),
+            ]
+        ),
+    )
+
+
+def test_energylogistic_hazard() -> None:
+    hf = bd.EnergyLogisticHazard(alpha=1.0, scale=1.0, e0=3.0)
+    age = jnp.array([10.0, 110.0, 10.0, 110.0])
+    energy = jnp.array([0.0, 0.0, 20.0, 20.0])
+    hazard = hf(age, energy)
+    chex.assert_trees_all_close(
+        hazard,
+        jnp.array(
+            [
+                1.0 - (1.0 / (1.0 + jnp.exp(3.0))),
+                1.0 - (1.0 / (1.0 + jnp.exp(3.0))),
+                1.0 - (1.0 / (1.0 + jnp.exp(-17.0))),
+                1.0 - (1.0 / (1.0 + jnp.exp(-17.0))),
+            ]
+        ),
+    )
+
+
+def test_gompertz_hazard() -> None:
+    hf = bd.GompertzHazard(alpha_const=1e-5, alpha_energy=1e-6, gamma=1.0, beta=1e-5)
+    age = jnp.array([10.0, 110.0, 10.0, 110.0])
+    energy = jnp.array([0.0, 0.0, 20.0, 20.0])
+    hazard = hf(age, energy)
+    chex.assert_trees_all_close(
+        hazard,
+        jnp.array(
+            [
+                (1e-5 + 1e-6 * jnp.exp(0.0)) * jnp.exp(1e-5 * 10.0),
+                (1e-5 + 1e-6 * jnp.exp(0.0)) * jnp.exp(1e-5 * 110.0),
+                (1e-5 + 1e-6 * jnp.exp(-20.0)) * jnp.exp(1e-5 * 10.0),
+                (1e-5 + 1e-6 * jnp.exp(-20.0)) * jnp.exp(1e-5 * 110.0),
+            ]
+        ),
+    )
+
+
+def test_elgompertz_hazard() -> None:
+    hf = bd.ELGompertzHazard(alpha=1.0, scale=1.0, e0=3.0, alpha_age=1e-6, beta=1e-5)
+    age = jnp.array([10.0, 110.0, 10.0, 110.0])
+    energy = jnp.array([0.0, 0.0, 20.0, 20.0])
+    hazard = hf(age, energy)
+    chex.assert_trees_all_close(
+        hazard,
+        jnp.array(
+            [
+                1.0 - (1.0 / (1.0 + jnp.exp(3.0))) + 1e-6 * jnp.exp(1e-5 * 10),
+                1.0 - (1.0 / (1.0 + jnp.exp(3.0))) + 1e-6 * jnp.exp(1e-5 * 110),
+                1.0 - (1.0 / (1.0 + jnp.exp(-17.0))) + 1e-6 * jnp.exp(1e-5 * 10),
+                1.0 - (1.0 / (1.0 + jnp.exp(-17.0))) + 1e-6 * jnp.exp(1e-5 * 110),
+            ]
+        ),
+    )
+
+
+def test_energylogistic_birth() -> None:
+    hf = bd.EnergyLogisticBirth(alpha=1.0, scale=0.1, e0=8.0)
+    age = jnp.array([10.0, 110.0, 10.0, 110.0])
+    energy = jnp.array([0.0, 0.0, 20.0, 20.0])
+    hazard = hf(age, energy)
+    chex.assert_trees_all_close(
+        hazard,
+        jnp.array(
+            [
+                0.1 / (1.0 + jnp.exp(8.0)),
+                0.1 / (1.0 + jnp.exp(8.0)),
+                0.1 / (1.0 + jnp.exp(-12.0)),
+                0.1 / (1.0 + jnp.exp(-12.0)),
+            ]
+        ),
+    )
+
+
+def test_evaluate_hazard() -> None:
+    hf = bd.ELGompertzHazard(alpha=1.0, scale=1.0, e0=3.0, alpha_age=1e-6, beta=1e-5)
+    energy = jnp.array(
+        [
+            [0.0, 10.0, 20.0],
+            [10.0, 10.0, 10.0],
+            [20.0, 10.0, 0.0],
+        ]
+    )
+    age_from = jnp.array([10.0, 10.0, 0.0])
+    age_to = jnp.array([20.0, 20.0, 10.0])
+    hazard = bd.evaluate_hazard(hf, age_from, age_to, energy)
+    chex.assert_trees_all_close(
+        hazard,
+        jnp.array(
+            [
+                1.0 - (1.0 / (1.0 + jnp.exp(3.0))) + 1e-6 * jnp.exp(1e-5 * 10),
+                1.0 - (1.0 / (1.0 + jnp.exp(3.0))) + 1e-6 * jnp.exp(1e-5 * 110),
+                1.0 - (1.0 / (1.0 + jnp.exp(-17.0))) + 1e-6 * jnp.exp(1e-5 * 10),
+                1.0 - (1.0 / (1.0 + jnp.exp(-17.0))) + 1e-6 * jnp.exp(1e-5 * 110),
+            ]
+        ),
+    )

From 3a8ab7cd687223a83032800e602894a9b8b2f990 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 28 Nov 2023 18:09:36 +0900
Subject: [PATCH 095/337] plotting functions

---
 notebooks/bd_rate.ipynb       | 491 ++++++++++++++++++++++++++++++++++
 pyproject.toml                |   1 -
 src/emevo/birth_and_death.py  |  63 +++--
 src/emevo/plotting.py         | 277 +++++++++++++++++++
 tests/test_birth_and_death.py |  20 +-
 5 files changed, 810 insertions(+), 42 deletions(-)
 create mode 100644 notebooks/bd_rate.ipynb
 create mode 100644 src/emevo/plotting.py

diff --git a/notebooks/bd_rate.ipynb b/notebooks/bd_rate.ipynb
new file mode 100644
index 00000000..ed69fb4e
--- /dev/null
+++ b/notebooks/bd_rate.ipynb
@@ -0,0 +1,491 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "0dadbf8d-d3eb-42b8-a9c1-265e61f6edd8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import dataclasses\n",
+    "from typing import Any, Literal\n",
+    "\n",
+    "import ipywidgets as widgets\n",
+    "import numpy as np\n",
+    "from emevo import birth_and_death as bd\n",
+    "from matplotlib import pyplot as plt\n",
+    "from matplotlib.figure import Figure\n",
+    "from matplotlib.lines import Line2D\n",
+    "from matplotlib.text import Text\n",
+    "from mpl_toolkits.mplot3d.art3d import Poly3DCollection\n",
+    "\n",
+    "from emevo.plotting import (\n",
+    "    vis_birth,\n",
+    "    vis_expected_n_children,\n",
+    "    vis_hazard,\n",
+    "    vis_lifetime,\n",
+    "    show_params_text,\n",
+    ")\n",
+    "\n",
+    "%matplotlib ipympl"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c4b6ebde-ea34-4a3e-92b3-964ac39c8452",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_slider(\n",
+    "    vmin: float,\n",
+    "    vmax: float,\n",
+    "    logscale: bool = True,\n",
+    "    n_steps: int = 400,\n",
+    ") -> widgets.FloatSlider | widgets.FloatLogSlider:\n",
+    "    if logscale:\n",
+    "        logmin = np.log10(vmin)\n",
+    "        logmax = np.log10(vmax)\n",
+    "        logstep = (logmax - logmin) / n_steps\n",
+    "        return widgets.FloatLogSlider(\n",
+    "            min=logmin,\n",
+    "            max=logmax,\n",
+    "            step=logstep,\n",
+    "            value=10 ** ((logmax + logmin) / 2.0),\n",
+    "            base=10,\n",
+    "            readout_format=\".3e\",\n",
+    "        )\n",
+    "    else:\n",
+    "        return widgets.FloatSlider(\n",
+    "            min=vmin,\n",
+    "            max=vmax,\n",
+    "            step=(vmax - vmin) / n_steps,\n",
+    "            value=(vmax + vmin) / 2,\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "8d94990f-99ac-4dc0-a5c9-1b19806b8885",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def savefig_widgets(fig: Figure) -> list:\n",
+    "    text = widgets.Text(\n",
+    "        value=\"figure.png\",\n",
+    "        description=\"Filename:\",\n",
+    "        disabled=False,\n",
+    "    )\n",
+    "    button = widgets.Button(description=\"Save File\")\n",
+    "    output = widgets.Output()\n",
+    "\n",
+    "    def on_button_clicked(b):\n",
+    "        filename = text.value\n",
+    "        if any([filename.endswith(ext) for ext in [\".png\", \".svg\", \".pdf\"]]):\n",
+    "            fig.savefig(filename)\n",
+    "        else:\n",
+    "            with output:\n",
+    "                print(\"Enter valid file name!\")\n",
+    "    \n",
+    "    button.on_click(on_button_clicked)\n",
+    "    return [text, button, output]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "8c0388cd-0f78-4094-8129-a448bd2446e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_hazard_widget(\n",
+    "    age_max: int = 10000,\n",
+    "    energy_max: float = 16,\n",
+    "    n_discr: int = 101,\n",
+    "    hazard_cls: type[bd.HazardFunction] = bd.GompertzHazard,\n",
+    "    methods: list[Literal[\"hazard\", \"cumulative hazard\", \"survival\"]] = [\"hazard\"],\n",
+    "    fixed_params: dict[str, Any] = {},\n",
+    "    **kwargs,\n",
+    ") -> widgets.VBox:\n",
+    "    n_methods = len(methods)\n",
+    "    fig = plt.figure(figsize=(6, 6 * n_methods))\n",
+    "    axes = []\n",
+    "    for i in range(n_methods):\n",
+    "        ax = fig.add_subplot(n_methods, 1, i + 1, projection=\"3d\")\n",
+    "        ax.set_title(f\"{hazard_cls.__name__} {methods[i]} function\")\n",
+    "        axes.append(ax)\n",
+    "\n",
+    "    @dataclasses.dataclass\n",
+    "    class State:\n",
+    "        surfs: list[Poly3DCollection]\n",
+    "        text: Text | None = None\n",
+    "\n",
+    "    state = State([None] * len(methods), None)\n",
+    "\n",
+    "    def update_figure(**params):\n",
+    "        hazard_fn = hazard_cls(**fixed_params, **params)\n",
+    "        if state.text is None:\n",
+    "            initial = True\n",
+    "        else:\n",
+    "            initial = False\n",
+    "            state.text.remove()\n",
+    "        for i in range(len(methods)):\n",
+    "            if state.surfs[i] is not None:\n",
+    "                state.surfs[i].remove()\n",
+    "            state.surfs[i], text = vis_hazard(\n",
+    "                axes[i],\n",
+    "                hazard_fn=hazard_fn,\n",
+    "                age_max=age_max,\n",
+    "                energy_max=energy_max,\n",
+    "                n_discr=n_discr,\n",
+    "                method=methods[i],\n",
+    "                initial=initial,\n",
+    "                shown_params=params if i == 0 else None,\n",
+    "            )\n",
+    "            if i == 0:\n",
+    "                state.text = text\n",
+    "        fig.canvas.draw()\n",
+    "        fig.canvas.flush_events()\n",
+    "\n",
+    "    sliders = {key: make_slider(*range_) for key, range_ in kwargs.items()}\n",
+    "    interactive = widgets.interactive(update_figure, **sliders)\n",
+    "    return widgets.VBox(savefig_widgets(fig) + [interactive])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f6e5195d-4ce1-4b04-a74b-a7abe805810b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_n_children_widget(\n",
+    "    energy_max: float = 16,\n",
+    "    n_discr: int = 101,\n",
+    "    birth_cls: type[bd.BirthFunction] = bd.EnergyLogisticBirth,\n",
+    "    hazard_cls: type[bd.HazardFunction] = bd.GompertzHazard,\n",
+    "    hazard_fixed_params: dict[str, Any] = {},\n",
+    "    birth_fixed_params: dict[str, Any] = {},\n",
+    "    **kwargs,\n",
+    ") -> widgets.VBox:\n",
+    "    fig = plt.figure(figsize=(6, 12))\n",
+    "    ax1 = fig.add_subplot(211)\n",
+    "    ax1.set_title(f\"{hazard_cls.__name__} Expected Lifetime\")\n",
+    "    ax2 = fig.add_subplot(212)\n",
+    "    ax2.set_title(f\"{hazard_cls.__name__} Expected Num. of children\")\n",
+    "\n",
+    "    @dataclasses.dataclass\n",
+    "    class State:\n",
+    "        lines: list[Line2D | None] \n",
+    "        texts: list[Text]\n",
+    "\n",
+    "    state = State([None, None], [])\n",
+    "\n",
+    "    def update_figure(**params):\n",
+    "        hazard_params, birth_params = {}, {}\n",
+    "        for key, value in params.items():\n",
+    "            if key.startswith(\"birth_\"):\n",
+    "                birth_params[key[len(\"birth_\") :]] = value\n",
+    "            else:\n",
+    "                hazard_params[key] = value\n",
+    "\n",
+    "        hazard_fn = hazard_cls(**hazard_fixed_params, **hazard_params)\n",
+    "        birth_fn = birth_cls(**birth_fixed_params, **birth_params)\n",
+    "        if len(state.texts) == 0:\n",
+    "            initial = True\n",
+    "        else:\n",
+    "            initial = False\n",
+    "            for text in state.texts:\n",
+    "                text.remove()\n",
+    "            state.texts.clear()\n",
+    "            for line in state.lines:\n",
+    "                line.remove()\n",
+    "\n",
+    "        state.lines[0] = vis_lifetime(\n",
+    "            ax1,\n",
+    "            hazard_fn=hazard_fn,\n",
+    "            energy_max=energy_max,\n",
+    "            n_discr=n_discr,\n",
+    "            initial=initial,\n",
+    "        )\n",
+    "        state.lines[1] = vis_expected_n_children(\n",
+    "            ax2,\n",
+    "            birth_fn=birth_fn,\n",
+    "            hazard_fn=hazard_fn,\n",
+    "            energy_max=energy_max,\n",
+    "            n_discr=n_discr,\n",
+    "            initial=initial,\n",
+    "        )\n",
+    "        state.texts = show_params_text(ax1, params, columns=2)\n",
+    "\n",
+    "        fig.canvas.draw()\n",
+    "        fig.canvas.flush_events()\n",
+    "\n",
+    "    sliders = {key: make_slider(*range_) for key, range_ in kwargs.items()}\n",
+    "    interactive = widgets.interactive(update_figure, **sliders)\n",
+    "    return widgets.VBox(savefig_widgets(fig) + [interactive])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "b6836a43-b466-4d86-9094-21a3560624cd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_birth_widget(\n",
+    "    age_max: int = 10000,\n",
+    "    energy_max: float = 16,\n",
+    "    n_discr: int = 101,\n",
+    "    birth_cls: type[bd.BirthFunction] = bd.EnergyLogisticBirth,\n",
+    "    **kwargs,\n",
+    ") -> widgets.VBox:\n",
+    "    fig = plt.figure(figsize=(6, 6))\n",
+    "    ax = fig.add_subplot(111, projection=\"3d\")\n",
+    "    ax.set_title(f\"{birth_cls.__name__} birth function\")\n",
+    "\n",
+    "    @dataclasses.dataclass\n",
+    "    class State:\n",
+    "        surf: Poly3DCollection | None = None\n",
+    "        text: Text | None = None\n",
+    "\n",
+    "    state = State()\n",
+    "\n",
+    "    def update_figure(**params):\n",
+    "        birth_fn = birth_cls(**params)\n",
+    "        if state.text is not None and state.surf is not None:\n",
+    "            initial = False\n",
+    "            state.text.remove()\n",
+    "            state.surf.remove()\n",
+    "        else:\n",
+    "            initial = True\n",
+    "\n",
+    "        state.surf, state.text = vis_birth(\n",
+    "            ax,\n",
+    "            birth_fn=birth_fn,\n",
+    "            age_max=age_max,\n",
+    "            energy_max=energy_max,\n",
+    "            n_discr=n_discr,\n",
+    "            initial=initial,\n",
+    "            shown_params=params,\n",
+    "        )\n",
+    "\n",
+    "        fig.canvas.draw()\n",
+    "        fig.canvas.flush_events()\n",
+    "\n",
+    "    sliders = {key: make_slider(*range_) for key, range_ in kwargs.items()}\n",
+    "    interactive = widgets.interactive(update_figure, **sliders)\n",
+    "    return widgets.VBox(savefig_widgets(fig) + [interactive])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "caf049a1-8651-46bf-82e8-84c249545b13",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bd4eab399971473ebcf6f115af6035c9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(Text(value='figure.png', description='Filename:'), Button(description='Save File', style=Button…"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b9887936ad9c469f859ba4d07230521f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "make_hazard_widget(\n",
+    "    scale=(1e-3, 1.0),\n",
+    "    e0=(0, 10, False),\n",
+    "    alpha_age=(1e-6, 1e-3),\n",
+    "    beta=(1e-5, 1e-3),\n",
+    "    methods=[\"hazard\", \"survival\"],\n",
+    "    age_max=10000,\n",
+    "    energy_max=20,\n",
+    "    hazard_cls=bd.ELGompertzHazard,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "345da544-b55e-4747-af47-83678795a34a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ba38ba9e213a4a1292d53bf5ff083702",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(Text(value='figure.png', description='Filename:'), Button(description='Save File', style=Button…"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bb149c3df1344e7598e921bb737a8a5a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "make_birth_widget(\n",
+    "    scale=(1e-6, 1e-3),\n",
+    "    alpha=(1e-2, 1.0),\n",
+    "    e0=(0, 10, False),\n",
+    "    age_max=200000,\n",
+    "    energy_max=10,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "aa8772da-cede-4eff-870b-d2435c902662",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6bb30290f1374e1da53b266d158cf480",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(Text(value='figure.png', description='Filename:'), Button(description='Save File', style=Button…"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "210c1b3bc02c45ada6ff0fe5e173a685",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "make_n_children_widget(\n",
+    "    alpha=(1e-2, 1.0),\n",
+    "    scale=(1e-3, 1.0),\n",
+    "    e0=(0, 10, False),\n",
+    "    alpha_age=(1e-7, 1e-4),\n",
+    "    beta=(1e-5, 1e-3),\n",
+    "    energy_max=20,\n",
+    "    hazard_cls=bd.ELGompertzHazard,\n",
+    "    birth_scale=(1e-6, 1e-3),\n",
+    "    birth_alpha=(1e-2, 1.0),\n",
+    "    birth_e0=(0, 10, False),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ae2e473a-2cb6-4827-a157-407395c4a039",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "emevo-lab",
+   "language": "python",
+   "name": "emevo-lab"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pyproject.toml b/pyproject.toml
index 1e823770..8d9c043c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -24,7 +24,6 @@ dependencies = [
     "equinox >= 0.11",
     "jax >= 0.4",
     "optax >= 0.1",
-    "scipy >= 1.0",
 ]
 dynamic = ["version"]
 
diff --git a/src/emevo/birth_and_death.py b/src/emevo/birth_and_death.py
index dbddc36b..8d9a1cf2 100644
--- a/src/emevo/birth_and_death.py
+++ b/src/emevo/birth_and_death.py
@@ -5,7 +5,7 @@
 
 import jax
 import jax.numpy as jnp
-from scipy import integrate
+from jax.scipy.integrate import trapezoid
 
 
 class HazardFunction(Protocol):
@@ -178,6 +178,9 @@ def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         return age * self(age, energy)
 
 
+N = 100000
+
+
 def compute_cumulative_hazard(
     hazard: HazardFunction,
     *,
@@ -185,14 +188,8 @@ def compute_cumulative_hazard(
     max_age: float = 1e6,
 ) -> float:
     """Compute cumulative hazard using numeric integration"""
-    energy_arr = jnp.array(energy)
-    result = integrate.quad(
-        lambda t: hazard(jnp.array(t), energy_arr).item(),
-        0.0,
-        max_age,
-        limit=10000,
-    )
-    return result[0]
+    age = jnp.linspace(0.0, max_age, N)
+    return trapezoid(y=hazard(age, jnp.ones(N) * energy), x=age)
 
 
 def compute_cumulative_survival(
@@ -202,13 +199,8 @@ def compute_cumulative_survival(
     max_age: float = 1e6,
 ) -> float:
     """Compute cumulative survival rate using numeric integration"""
-    energy_arr = jnp.array(energy)
-    result = integrate.quad(
-        lambda t: hazard(jnp.array(t), energy_arr).item(),
-        0,
-        max_age,
-    )
-    return result[0]
+    age = jnp.linspace(0.0, max_age, N)
+    return trapezoid(y=hazard.survival(age, jnp.ones(N) * energy), x=age)
 
 
 def compute_stable_birth_rate(
@@ -222,20 +214,37 @@ def compute_stable_birth_rate(
     return 1.0 / cumsuv
 
 
-def expected_n_children(
+def compute_expected_n_children(
     *,
     birth: BirthFunction,
     hazard: HazardFunction,
     max_age: float = 1e6,
     energy: float = 10.0,
 ) -> float:
-    energy_arr = jnp.array(energy)
-
-    def integrated(t: float) -> float:
-        age_arr = jnp.array(t)
-        b = birth(age_arr, energy_arr).item()
-        h = hazard.survival(age_arr, energy_arr).item()
-        return h * b
-
-    result = integrate.quad(integrated, 0, max_age)
-    return result[0]
+    age = jnp.linspace(0.0, max_age, N)
+    energy_arr = jnp.ones(N) * energy
+    s = hazard.survival(age, energy_arr)
+    b = birth(age, energy_arr)
+    return trapezoid(y=s * b, x=age)
+
+
+def _step_survival(s_t: jax.Array, h_t1: jax.Array) -> tuple[jax.Array, None]:
+    return s_t * (1.0 - h_t1), None
+
+
+def evaluate_hazard_and_birth(
+    bf: BirthFunction,
+    hf: HazardFunction,
+    age_from: jax.Array,  # (M,)
+    age_to: jax.Array,  # (M,)
+    energy: jax.Array,  # (N, M)
+    dx: float = 1.0,
+) -> tuple[jax.Array, jax.Array]:
+    n, m = energy.shape
+    ages = jnp.linspace(age_from, age_to, n)
+    hazard = jax.vmap(hf)(ages, energy)
+    cumulative_hazard = trapezoid(y=hazard, x=ages, dx=dx, axis=0)
+    bitrh = jax.vmap(bf)(ages, energy)
+    survival = jnp.exp(-cumulative_hazard)
+    expected_n_children = trapezoid(y=hazard * birth, x=ages, dx=dx, axis=0)
+    return survival, 1.0 - jnp.exp(-expected_n_children)
diff --git a/src/emevo/plotting.py b/src/emevo/plotting.py
new file mode 100644
index 00000000..5ae8e33b
--- /dev/null
+++ b/src/emevo/plotting.py
@@ -0,0 +1,277 @@
+from typing import Literal, cast
+
+import jax
+import jax.numpy as jnp
+import matplotlib as mpl
+import numpy as np
+from matplotlib import pyplot as plt
+from matplotlib import ticker
+from matplotlib.axes import Axes
+from matplotlib.cm import ScalarMappable
+from matplotlib.colors import Colormap, Normalize
+from matplotlib.figure import Figure
+from matplotlib.lines import Line2D
+from matplotlib.text import Text
+from mpl_toolkits.mplot3d import Axes3D
+from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+from numpy.typing import NDArray
+
+from emevo import birth_and_death as bd
+
+mpl.use("Agg")
+
+
+class CBarRenderer:
+    """Render colorbar to numpy array"""
+
+    def __init__(
+        self,
+        width: float,
+        height: float,
+        dpi: int = 100,
+    ) -> None:
+        self._fig: Figure = cast(
+            Figure,
+            plt.figure(figsize=(width / dpi, height / dpi), dpi=dpi),
+        )
+        self._ax: Axes = self._fig.add_axes([0.0, 0.2, 1.0, 0.6])
+
+    def render(self, norm: Normalize, cm: Colormap, title: str = "Value") -> None:
+        """Render cbar, but don't update figure"""
+        self._ax.clear()
+        mappable = ScalarMappable(norm=norm, cmap=cm)
+        self._fig.colorbar(mappable, cax=self._ax, orientation="horizontal")
+        self._ax.set_title(title)
+
+    def render_to_array(
+        self,
+        norm: Normalize,
+        cm: Colormap,
+        title: str = "Value",
+    ) -> NDArray:
+        self.render(norm, cm, title)
+        self._fig.canvas.draw()
+        array = np.frombuffer(self._fig.canvas.tostring_rgb(), dtype=np.uint8)
+        w, h = self._fig.canvas.get_width_height()
+        return array.reshape(h, w, -1)
+
+
+def vis_birth_2d(
+    ax: Axes,
+    birth_fn: bd.BirthFunction,
+    energy_max: float = 16,
+    age: float = 100.0,
+    initial: bool = True,
+) -> Line2D:
+    energy_max_int = int(energy_max)
+    birthrate = birth_fn(
+        age=jnp.ones(energy_max_int) * age,
+        energy=jnp.arange(energy_max),
+    )
+    lines = ax.plot(np.arange(energy_max_int), birthrate, color="xkcd:bluish purple")
+    if initial:
+        ax.grid(True, which="major")
+        ax.set_xlabel("Energy", fontsize=12)
+        ax.yaxis.set_major_formatter("{x:.0e}")
+        ax.set_ylabel("Birth Rate", fontsize=12)
+    return cast(Line2D, lines[0])
+
+
+def vis_lifetime(
+    ax: Axes,
+    hazard_fn: bd.HazardFunction,
+    energy_max: float = 16,
+    n_discr: int = 101,
+    initial: bool = True,
+) -> Line2D:
+    energy_space = np.linspace(energy_max, 0.0, n_discr)
+    lifetime = np.zeros(n_discr)
+    for i in range(n_discr):
+        lifetime[i] = bd.compute_cumulative_survival(
+            hazard_fn,
+            energy=energy_space[i],
+            max_age=1000000,
+        )
+    lines = ax.plot(energy_space, lifetime, color="xkcd:bluish purple")
+    if initial:
+        ax.grid(True, which="major")
+        ax.set_xlabel("Energy", fontsize=12)
+        ax.yaxis.set_major_formatter("{x:.0e}")
+        ax.set_ylabel("Expected Lifetime", fontsize=12)
+    return cast(Line2D, lines[0])
+
+
+def vis_expected_n_children(
+    ax: Axes3D,
+    hazard_fn: bd.HazardFunction,
+    birth_fn: bd.BirthFunction,
+    energy_max: float = 16,
+    n_discr: int = 101,
+    initial: bool = True,
+) -> Line2D:
+    energy_space = np.linspace(energy_max, 0.0, n_discr)
+    n_children = np.zeros(n_discr)
+    max_n_children = 0
+    for i in range(n_discr):
+        n_children[i] = bd.compute_expected_n_children(
+            birth=birth_fn,
+            hazard=hazard_fn,
+            energy=energy_space[i],
+            max_age=1000000,
+        )
+        max_n_children = max(max_n_children, n_children[i])
+    lines = ax.plot(energy_space, n_children, color="xkcd:bluish purple")
+    if initial:
+        ax.grid(True, which="major")
+        ax.set_xlabel("Energy", fontsize=12)
+        ax.set_ylabel("Expected Num. of children", fontsize=12)
+    return cast(Line2D, lines[0])
+
+
+def show_params_text(
+    ax: Axes,
+    params: dict[str, float | int],
+    columns: int = 1,
+) -> list[Text]:
+    params_list = list(params.items())
+    n_params = len(params_list)
+    unit = n_params // columns
+    texts = []
+    for i in range(columns):
+        start = unit * i
+        end = min(n_params, start + unit)
+        text = ax.text(
+            i * 0.9 / columns,
+            1.1,
+            "\n".join([f"{key}: {value:.2e}" for key, value in params_list[start:end]]),
+            transform=ax.transAxes,
+        )
+        texts.append(text)
+    return texts
+
+
+def vis_hazard(
+    ax: Axes3D,
+    hazard_fn: bd.HazardFunction,
+    age_max: int = 10000,
+    energy_max: float = 16,
+    n_discr: int = 101,
+    method: Literal["hazard", "cumulative hazard", "survival"] = "hazard",
+    initial: bool = True,
+    shown_params: dict[str, float] | None = None,
+) -> tuple[Poly3DCollection, Text | None]:
+    age_space = jnp.linspace(0, age_max, n_discr)
+    energy_space = jnp.linspace(energy_max, 0.0, n_discr)
+    if method == "hazard":
+        hf = hazard_fn
+    elif method == "cumulative hazard":
+        hf = hazard_fn.cumulative
+    elif method == "survival":
+        hf = hazard_fn.survival
+    else:
+        raise ValueError(f"Unsupported method {method}")
+
+    death_prob = jax.vmap(lambda e: hf(age_space, jnp.ones(n_discr) * e))(energy_space)
+    x, y = np.meshgrid(age_space, energy_space)
+    surf = ax.plot_surface(
+        x,
+        y,
+        death_prob,
+        cmap="plasma",
+        linewidth=0,
+        antialiased=True,
+    )
+    if initial:
+        ax.set_xlim((age_max, 0.0))
+        ax.set_ylim((0.0, energy_max))
+        if method == "survival":
+            ax.set_zlim((0.0, 1.0))
+        else:
+            ax.set_zscale("log")  # type: ignore
+            ax.zaxis.set_major_locator(ticker.LogLocator(base=100, numticks=10))
+            ax.zaxis.set_major_formatter(
+                ticker.FuncFormatter(lambda x, _: f"{x:.0e}".replace("e-0", "e-"))
+            )
+
+        ax.set_xlabel("Age", fontsize=12)
+
+        def format_age(x: float, _pos) -> str:
+            del _pos
+            if x > 10000:
+                return f"{int(x) // 1000}K"
+            else:
+                return str(int(x))
+
+        ax.xaxis.set_major_formatter(ticker.FuncFormatter(format_age))
+        ax.xaxis.set_ticks(np.linspace(age_max, 0.0, 5))
+        ax.yaxis.set_ticks(np.linspace(0.0, energy_max, 5))
+        ax.set_ylabel("Energy", fontsize=12)
+        ax.set_zlabel(method.capitalize(), fontsize=14, horizontalalignment="right")
+    if shown_params is not None:
+        text = ax.text2D(
+            -0.1,
+            0.12,
+            "\n".join([f"{key}: {value:.2e}" for key, value in shown_params.items()]),
+        )
+    else:
+        text = None
+    return surf, text
+
+
+def vis_survivorship(
+    ax: Axes,
+    hazard_fn: bd.HazardFunction,
+    age_max: int = 100000,
+    energy: float = 10,
+    initial: bool = True,
+    color: str = "xkcd:bluish purple",
+) -> Line2D:
+    survival = hazard_fn.survival(jnp.arange(age_max), jnp.ones(age_max) * energy)
+    lines = ax.plot(np.arange(age_max), survival, color=color)
+    if initial:
+        ax.grid(True, which="major")
+        ax.set_xlabel("Age", fontsize=12)
+        ax.set_ylabel("Survival Rate", fontsize=12)
+        ax.set_ylim((0.0, 1.0))
+    return cast(Line2D, lines[0])
+
+
+def vis_birth(
+    ax: Axes3D,
+    birth_fn: bd.BirthFunction,
+    age_max: int = 10000,
+    energy_max: float = 16,
+    n_discr: int = 101,
+    initial: bool = True,
+    shown_params: dict[str, float] | None = None,
+) -> tuple[Poly3DCollection, Text | None]:
+    age_space = jnp.linspace(0, age_max, n_discr)
+    energy_space = jnp.linspace(energy_max, 0.0, n_discr)
+
+    birth_prob = jax.vmap(lambda e: birth_fn(age_space, jnp.ones(n_discr) * e))(
+        energy_space
+    )
+    x, y = np.meshgrid(age_space, energy_space)
+    surf = ax.plot_surface(
+        x,
+        y,
+        birth_prob,
+        cmap="plasma",
+        linewidth=0,
+        antialiased=True,
+    )
+    if initial:
+        ax.set_xlim((age_max, 0.0))
+        ax.set_ylim((0.0, energy_max))
+        ax.set_xlabel("Age", fontsize=12)
+        ax.set_ylabel("Energy", fontsize=12)
+        ax.set_zlabel("Birth rate", fontsize=14, horizontalalignment="right")
+    if shown_params is None:
+        text = None
+    else:
+        text = ax.text2D(
+            -0.1,
+            0.08,
+            "\n".join([f"{key}: {value:.2e}" for key, value in shown_params.items()]),
+        )
+    return surf, text
diff --git a/tests/test_birth_and_death.py b/tests/test_birth_and_death.py
index 42e7d317..018a0a9f 100644
--- a/tests/test_birth_and_death.py
+++ b/tests/test_birth_and_death.py
@@ -102,26 +102,18 @@ def test_energylogistic_birth() -> None:
     )
 
 
-def test_evaluate_hazard() -> None:
+def test_evaluate_birth_and_hazard() -> None:
+    N, M = 4, 3
     hf = bd.ELGompertzHazard(alpha=1.0, scale=1.0, e0=3.0, alpha_age=1e-6, beta=1e-5)
     energy = jnp.array(
         [
             [0.0, 10.0, 20.0],
             [10.0, 10.0, 10.0],
             [20.0, 10.0, 0.0],
+            [30.0, 10.0, 10.0],
         ]
     )
     age_from = jnp.array([10.0, 10.0, 0.0])
-    age_to = jnp.array([20.0, 20.0, 10.0])
-    hazard = bd.evaluate_hazard(hf, age_from, age_to, energy)
-    chex.assert_trees_all_close(
-        hazard,
-        jnp.array(
-            [
-                1.0 - (1.0 / (1.0 + jnp.exp(3.0))) + 1e-6 * jnp.exp(1e-5 * 10),
-                1.0 - (1.0 / (1.0 + jnp.exp(3.0))) + 1e-6 * jnp.exp(1e-5 * 110),
-                1.0 - (1.0 / (1.0 + jnp.exp(-17.0))) + 1e-6 * jnp.exp(1e-5 * 10),
-                1.0 - (1.0 / (1.0 + jnp.exp(-17.0))) + 1e-6 * jnp.exp(1e-5 * 110),
-            ]
-        ),
-    )
+    age_to = jnp.array([40.0, 40.0, 30.0])
+    cum_hazard = bd.evaluate_hazard(hf, age_from, age_to, energy)
+    chex.assert_shape(cum_hazard, (M,))

From 5f7b2fdb10d22c5624d013ae9a0b4ee179db0db0 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 29 Nov 2023 10:26:04 +0900
Subject: [PATCH 096/337] Remove evaluate birth

---
 src/emevo/birth_and_death.py  | 22 ----------------------
 tests/test_birth_and_death.py | 17 -----------------
 2 files changed, 39 deletions(-)

diff --git a/src/emevo/birth_and_death.py b/src/emevo/birth_and_death.py
index 8d9a1cf2..5d1db303 100644
--- a/src/emevo/birth_and_death.py
+++ b/src/emevo/birth_and_death.py
@@ -226,25 +226,3 @@ def compute_expected_n_children(
     s = hazard.survival(age, energy_arr)
     b = birth(age, energy_arr)
     return trapezoid(y=s * b, x=age)
-
-
-def _step_survival(s_t: jax.Array, h_t1: jax.Array) -> tuple[jax.Array, None]:
-    return s_t * (1.0 - h_t1), None
-
-
-def evaluate_hazard_and_birth(
-    bf: BirthFunction,
-    hf: HazardFunction,
-    age_from: jax.Array,  # (M,)
-    age_to: jax.Array,  # (M,)
-    energy: jax.Array,  # (N, M)
-    dx: float = 1.0,
-) -> tuple[jax.Array, jax.Array]:
-    n, m = energy.shape
-    ages = jnp.linspace(age_from, age_to, n)
-    hazard = jax.vmap(hf)(ages, energy)
-    cumulative_hazard = trapezoid(y=hazard, x=ages, dx=dx, axis=0)
-    bitrh = jax.vmap(bf)(ages, energy)
-    survival = jnp.exp(-cumulative_hazard)
-    expected_n_children = trapezoid(y=hazard * birth, x=ages, dx=dx, axis=0)
-    return survival, 1.0 - jnp.exp(-expected_n_children)
diff --git a/tests/test_birth_and_death.py b/tests/test_birth_and_death.py
index 018a0a9f..51f6446c 100644
--- a/tests/test_birth_and_death.py
+++ b/tests/test_birth_and_death.py
@@ -100,20 +100,3 @@ def test_energylogistic_birth() -> None:
             ]
         ),
     )
-
-
-def test_evaluate_birth_and_hazard() -> None:
-    N, M = 4, 3
-    hf = bd.ELGompertzHazard(alpha=1.0, scale=1.0, e0=3.0, alpha_age=1e-6, beta=1e-5)
-    energy = jnp.array(
-        [
-            [0.0, 10.0, 20.0],
-            [10.0, 10.0, 10.0],
-            [20.0, 10.0, 0.0],
-            [30.0, 10.0, 10.0],
-        ]
-    )
-    age_from = jnp.array([10.0, 10.0, 0.0])
-    age_to = jnp.array([40.0, 40.0, 30.0])
-    cum_hazard = bd.evaluate_hazard(hf, age_from, age_to, energy)
-    chex.assert_shape(cum_hazard, (M,))

From df6825b360f84739a9d63dc611b28e275f6b6c31 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 30 Nov 2023 16:39:08 +0900
Subject: [PATCH 097/337] Start preparing experiments

---
 experiments/cf_asexual_evo.py | 287 ++++++++++++++++++++++++++++++++++
 pyproject.toml                |   7 +-
 requirements/experiments.in   |   4 +
 requirements/smoke.in         |   2 +-
 src/emevo/_test_utils.py      |  71 ---------
 src/emevo/exp_utils.py        |  44 ++++++
 6 files changed, 339 insertions(+), 76 deletions(-)
 create mode 100644 experiments/cf_asexual_evo.py
 create mode 100644 requirements/experiments.in
 delete mode 100644 src/emevo/_test_utils.py
 create mode 100644 src/emevo/exp_utils.py

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
new file mode 100644
index 00000000..129705b7
--- /dev/null
+++ b/experiments/cf_asexual_evo.py
@@ -0,0 +1,287 @@
+"""Example of using circle foraging environment"""
+
+from pathlib import Path
+from typing import Optional
+
+import chex
+import equinox as eqx
+import jax
+import jax.numpy as jnp
+import numpy as np
+import optax
+import typer
+
+from emevo import Env, Profile, make
+from emevo.env import ObsProtocol as Obs
+from emevo.env import StateProtocol as State
+from emevo.rl.ppo_normal import (
+    NormalPPONet,
+    Rollout,
+    vmap_apply,
+    vmap_batch,
+    vmap_net,
+    vmap_update,
+    vmap_value,
+)
+from emevo.visualizer import SaveVideoWrapper
+
+N_MAX_AGENTS: int = 10
+
+
+def weight_summary(network):
+    params, _ = eqx.partition(network, eqx.is_inexact_array)
+    params_mean = jax.tree_map(jnp.mean, params)
+    for k, v in jax.tree_util.tree_leaves_with_path(params_mean):
+        print(k, v)
+
+
+def visualize(
+    key: chex.PRNGKey,
+    env: Env,
+    network: NormalPPONet,
+    n_steps: int,
+    videopath: Path | None,
+    headless: bool,
+) -> None:
+    keys = jax.random.split(key, n_steps + 1)
+    state, ts = env.reset(keys[0])
+    obs = ts.obs
+    backend = "headless" if headless else "pyglet"
+    visualizer = env.visualizer(state, figsize=(640.0, 640.0), backend=backend)
+    if videopath is not None:
+        visualizer = SaveVideoWrapper(visualizer, videopath, fps=60)
+
+    # Returns action for debugging
+    @eqx.filter_jit
+    def step(key: chex.PRNGKey, state: State, obs: Obs) -> tuple[State, Obs, jax.Array]:
+        net_out = vmap_apply(network, obs.as_array())
+        actions = net_out.policy().sample(seed=key)
+        next_state, timestep = env.step(state, env.act_space.sigmoid_scale(actions))
+        return next_state, timestep.obs, actions
+
+    for key in keys[1:]:
+        state, obs, act = step(key, state, obs)
+        # print(f"Act: {act[0]}")
+        visualizer.render(state)
+        visualizer.show()
+
+
+def exec_rollout(
+    state: State,
+    initial_obs: Obs,
+    env: Env,
+    network: NormalPPONet,
+    prng_key: jax.Array,
+    n_rollout_steps: int,
+) -> tuple[State, Rollout, Obs, jax.Array]:
+    def step_rollout(
+        carried: tuple[State, Obs, Profile],
+        key: jax.Array,
+    ) -> tuple[tuple[State, Obs, Profile], Rollout]:
+        state_t, obs_t = carried
+        obs_t_array = obs_t.as_array()
+        net_out = vmap_apply(network, obs_t_array)
+        actions = net_out.policy().sample(seed=key)
+        state_t1, timestep = env.step(state_t, env.act_space.sigmoid_scale(actions))
+        rewards = obs_t.collision[:, 1].astype(jnp.float32).reshape(-1, 1)
+        rollout = Rollout(
+            observations=obs_t_array,
+            actions=actions,
+            rewards=rewards,
+            terminations=jnp.zeros_like(rewards),
+            values=net_out.value,
+            means=net_out.mean,
+            logstds=net_out.logstd,
+        )
+        return (state_t1, timestep.obs), rollout
+
+    (state, obs), rollout = jax.lax.scan(
+        step_rollout,
+        (state, initial_obs),
+        jax.random.split(prng_key, n_rollout_steps),
+    )
+    next_value = vmap_value(network, obs.as_array())
+    return state, rollout, obs, next_value
+
+
+@eqx.filter_jit
+def training_step(
+    state: State,
+    initial_obs: Obs,
+    env: Env,
+    network: NormalPPONet,
+    prng_key: jax.Array,
+    n_rollout_steps: int,
+    gamma: float,
+    gae_lambda: float,
+    adam_update: optax.TransformUpdateFn,
+    opt_state: optax.OptState,
+    minibatch_size: int,
+    n_optim_epochs: int,
+    reset: jax.Array,
+) -> tuple[State, Obs, jax.Array, optax.OptState, NormalPPONet]:
+    keys = jax.random.split(prng_key, N_MAX_AGENTS + 1)
+    env_state, rollout, obs, next_value = exec_rollout(
+        state,
+        initial_obs,
+        env,
+        network,
+        keys[0],
+        n_rollout_steps,
+    )
+    rollout = rollout.replace(terminations=rollout.terminations.at[-1].set(reset))
+    batch = vmap_batch(rollout, next_value, gamma, gae_lambda)
+    output = vmap_apply(network, obs.as_array())
+    opt_state, pponet = vmap_update(
+        batch,
+        network,
+        adam_update,
+        opt_state,
+        keys[1:],
+        minibatch_size,
+        n_optim_epochs,
+        0.2,
+        0.0,
+    )
+    return env_state, obs, rollout.rewards, opt_state, pponet
+
+
+def run_training(
+    key: jax.Array,
+    n_agents: int,
+    env: Env,
+    adam: optax.GradientTransformation,
+    gamma: float,
+    gae_lambda: float,
+    n_optim_epochs: int,
+    minibatch_size: int,
+    n_rollout_steps: int,
+    n_total_steps: int,
+    reset_interval: int | None = None,
+    debug_vis: bool = False,
+) -> NormalPPONet:
+    key, net_key, reset_key = jax.random.split(key, 3)
+    obs_space = env.obs_space.flatten()
+    input_size = np.prod(obs_space.shape)
+    act_size = np.prod(env.act_space.shape)
+    pponet = vmap_net(
+        input_size,
+        64,
+        act_size,
+        jax.random.split(net_key, N_MAX_AGENTS),
+    )
+    adam_init, adam_update = adam
+    opt_state = jax.vmap(adam_init)(eqx.filter(pponet, eqx.is_array))
+    env_state, timestep = env.reset(reset_key)
+    obs = timestep.obs
+
+    n_loop = n_total_steps // n_rollout_steps
+    rewards = jnp.zeros(N_MAX_AGENTS)
+    keys = jax.random.split(key, n_loop)
+    if debug_vis:
+        visualizer = env.visualizer(env_state, figsize=(640.0, 640.0))
+    else:
+        visualizer = None
+    for i, key in enumerate(keys):
+        reset = reset_interval is not None and (i + 1) % reset_interval
+        env_state, obs, rewards_i, opt_state, pponet = training_step(
+            env_state,
+            obs,
+            env,
+            pponet,
+            key,
+            n_rollout_steps,
+            gamma,
+            gae_lambda,
+            adam_update,
+            opt_state,
+            minibatch_size,
+            n_optim_epochs,
+            jnp.array(reset),
+        )
+        ri = jnp.sum(jnp.squeeze(rewards_i, axis=-1), axis=0)
+        rewards = rewards + ri
+        if visualizer is not None:
+            visualizer.render(env_state)
+            visualizer.show()
+            print(f"Rewards: {[x.item() for x in ri[: n_agents]]}")
+        if reset:
+            env_state, timestep = env.reset(key)
+            obs = timestep.obs
+        # weight_summary(pponet)
+    print(f"Sum of rewards {[x.item() for x in rewards[: n_agents]]}")
+    return pponet
+
+
+app = typer.Typer(pretty_exceptions_show_locals=False)
+
+
+@app.command()
+def train(
+    modelpath: Path = Path("trained.eqx"),
+    seed: int = 1,
+    n_agents: int = 2,
+    n_foods: int = 10,
+    obstacles: str = "none",
+    adam_lr: float = 3e-4,
+    adam_eps: float = 1e-7,
+    gamma: float = 0.999,
+    gae_lambda: float = 0.95,
+    n_optim_epochs: int = 10,
+    minibatch_size: int = 128,
+    n_rollout_steps: int = 1024,
+    n_total_steps: int = 1024 * 1000,
+    food_loc_fn: str = "gaussian",
+    env_shape: str = "circle",
+    reset_interval: Optional[int] = None,
+    xlim: int = 200,
+    ylim: int = 200,
+    linear_damping: float = 0.8,
+    angular_damping: float = 0.6,
+    max_force: float = 40.0,
+    min_force: float = -20.0,
+    debug_vis: bool = False,
+) -> None:
+    assert n_agents < N_MAX_AGENTS
+    env = make(
+        "CircleForaging-v0",
+        env_shape=env_shape,
+        n_max_agents=N_MAX_AGENTS,
+        n_initial_agents=n_agents,
+        food_num_fn=("constant", n_foods),
+        food_loc_fn=food_loc_fn,
+        agent_loc_fn="gaussian",
+        foodloc_interval=20,
+        obstacles=obstacles,
+        xlim=(0.0, float(xlim)),
+        ylim=(0.0, float(ylim)),
+        env_radius=min(xlim, ylim) * 0.5,
+        linear_damping=linear_damping,
+        angular_damping=angular_damping,
+        max_force=max_force,
+        min_force=min_force,
+    )
+    network = run_training(
+        jax.random.PRNGKey(seed),
+        n_agents,
+        env,
+        optax.adam(adam_lr, eps=adam_eps),
+        gamma,
+        gae_lambda,
+        n_optim_epochs,
+        minibatch_size,
+        n_rollout_steps,
+        n_total_steps,
+        reset_interval,
+        debug_vis,
+    )
+    eqx.tree_serialise_leaves(modelpath, network)
+
+
+@app.command()
+def vis() -> None:
+    assert False, "Unimplemented"
+
+
+if __name__ == "__main__":
+    app()
diff --git a/pyproject.toml b/pyproject.toml
index 8d9c043c..0adc4ebd 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -22,16 +22,15 @@ dependencies = [
     "chex >= 0.1.82",
     "distrax >= 0.1",
     "equinox >= 0.11",
+    "moderngl >= 5.6",
+    "moderngl-window >= 2.4",
     "jax >= 0.4",
+    "pyserde >= 0.12",
     "optax >= 0.1",
 ]
 dynamic = ["version"]
 
 [project.optional-dependencies]
-moderngl = [
-    "moderngl >= 5.6",
-    "moderngl-window >= 2.4"
-]
 pyside6 = ["PySide6 >= 6.4.1"]
 video = ["imageio-ffmpeg >= 0.4"]
 
diff --git a/requirements/experiments.in b/requirements/experiments.in
new file mode 100644
index 00000000..7bc2621b
--- /dev/null
+++ b/requirements/experiments.in
@@ -0,0 +1,4 @@
+-e .[video,pyside6]
+fastavro
+tqdm
+typer
\ No newline at end of file
diff --git a/requirements/smoke.in b/requirements/smoke.in
index 4b1b0a03..21e619c3 100644
--- a/requirements/smoke.in
+++ b/requirements/smoke.in
@@ -1,4 +1,4 @@
--e .[moderngl,video,pyside6]
+-e .[video,pyside6]
 py-spy  # for profiling
 tqdm
 typer
\ No newline at end of file
diff --git a/src/emevo/_test_utils.py b/src/emevo/_test_utils.py
deleted file mode 100644
index 6a86e3fa..00000000
--- a/src/emevo/_test_utils.py
+++ /dev/null
@@ -1,71 +0,0 @@
-"""
-Common utilities used in smoke tests and unit tests.
-Not expected to use externally.
-"""
-from __future__ import annotations
-
-import itertools
-
-import numpy as np
-from numpy.random import Generator
-from numpy.typing import NDArray
-
-from emevo import Body, spaces
-from emevo.environments import CircleForaging
-from emevo.environments.utils.food_repr import ReprLoc, ReprNum
-from emevo.environments.utils.locating import InitLoc
-
-
-class FakeBody(Body):
-    def __init__(self, act_dim: int = 1, obs_dim: int = 1) -> None:
-        act_space = spaces.BoxSpace(
-            np.zeros(act_dim, dtype=np.float32),
-            np.ones(act_dim, dtype=np.float32),
-        )
-        obs_space = spaces.BoxSpace(
-            np.zeros(obs_dim, dtype=np.float32),
-            np.ones(obs_dim, dtype=np.float32),
-        )
-        super().__init__(act_space, obs_space)
-
-    def location(self) -> NDArray:
-        return np.array(())
-
-
-def predefined_env(
-    *,
-    agent_locations: list[NDArray] | None = None,
-    food_locations: list[NDArray] | None = None,
-    **kwargs,
-) -> CircleForaging:
-    if agent_locations is None:
-        agent_locations = [
-            np.array([50, 60]),
-            np.array([50, 140]),
-            np.array([150, 40]),
-        ]
-    if food_locations is None:
-        food_locations = [np.array([150, 160])]
-
-    return CircleForaging(
-        n_initial_bodies=len(agent_locations),
-        body_loc_fn=InitLoc.PRE_DIFINED(agent_locations),
-        food_num_fn=ReprNum.CONSTANT(len(food_locations)),
-        food_loc_fn=ReprLoc.PRE_DIFINED(itertools.cycle(food_locations)),
-        **kwargs,
-    )
-
-
-def sample_location(
-    gen: Generator,
-    center: tuple[float, float],
-    radius_max: float,
-    radius_min: float = 0.0,
-) -> tuple[float, float]:
-    cx, cy = center
-    theta = gen.random() * 2.0 * np.pi
-    radius_range = radius_max - radius_min
-    radius = np.sqrt(gen.random()) * radius_range + radius_min
-    x = cx + radius * np.cos(theta)
-    y = cy + radius * np.sin(theta)
-    return x, y
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
new file mode 100644
index 00000000..4bec1008
--- /dev/null
+++ b/src/emevo/exp_utils.py
@@ -0,0 +1,44 @@
+"""Utility for experiments"""
+from __future__ import annotations
+
+import dataclasses
+import functools
+import importlib
+import os
+import pickle
+from collections import defaultdict
+from pathlib import Path
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    Iterable,
+    Mapping,
+    Sequence,
+    Type,
+    TypeVar,
+)
+
+import serde
+
+def _load_cls(cls_path: str) -> Type:
+    try:
+        mod, cls = cls_path.rsplit(".", 1)
+        return getattr(importlib.import_module(mod), cls)
+    except (AttributeError, ModuleNotFoundError, ValueError) as err:
+        raise ImportError(f"{cls_path} is not a valid class path") from err
+
+
+@serde
+@dataclasses.dataclass(frozen=True)
+class BDConfig:
+    birth_fn: str
+    birth_params: Dict[str, float]
+    hazard_fn: str
+    hazard_params: Dict[str, float]
+
+    def load_models(self) -> tuple[bd.birth.BirthFunction, bd.death.HazardFunction]:
+        birth_fn = _load_cls(self.birth_fn)(**self.birth_params)
+        hazard_fn = _load_cls(self.hazard_fn)(**self.hazard_params)
+        return birth_fn, hazard_fn

From 5a98be935d50d8016ff30335d09acc6f405adade Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 1 Dec 2023 16:44:26 +0900
Subject: [PATCH 098/337] CfConfig

---
 smoke-tests/circle_ppo.py |  1 -
 src/emevo/exp_utils.py    | 45 +++++++++++++++++++++++----------------
 2 files changed, 27 insertions(+), 19 deletions(-)

diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index fda24bb7..ae579014 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -131,7 +131,6 @@ def training_step(
     )
     rollout = rollout.replace(terminations=rollout.terminations.at[-1].set(reset))
     batch = vmap_batch(rollout, next_value, gamma, gae_lambda)
-    output = vmap_apply(network, obs.as_array())
     opt_state, pponet = vmap_update(
         batch,
         network,
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 4bec1008..64c6ac3a 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -2,26 +2,35 @@
 from __future__ import annotations
 
 import dataclasses
-import functools
 import importlib
-import os
-import pickle
-from collections import defaultdict
-from pathlib import Path
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Generic,
-    Iterable,
-    Mapping,
-    Sequence,
-    Type,
-    TypeVar,
-)
+from typing import Dict, List, Tuple, Type
 
 import serde
 
+from emevo import birth_and_death as bd
+
+
+@serde.serde
+@dataclasses.dataclass
+class CfConfig:
+    agent_radius: float
+    n_agents: int
+    n_agent_sensors: int
+    sensor_length: float
+    food_loc_fn: str
+    food_num_fn: Tuple["str", int]
+    xlim: Tuple[float, float]
+    ylim: Tuple[float, float]
+    env_radius: float
+    env_shape: str
+    obstacles: List[Tuple[float, float, float, float]]
+    seed: int
+    linear_damping: float = 0.8
+    angular_damping: float = 0.6
+    max_force: float = 40.0
+    min_force: float = -20.0
+
+
 def _load_cls(cls_path: str) -> Type:
     try:
         mod, cls = cls_path.rsplit(".", 1)
@@ -30,7 +39,7 @@ def _load_cls(cls_path: str) -> Type:
         raise ImportError(f"{cls_path} is not a valid class path") from err
 
 
-@serde
+@serde.serde
 @dataclasses.dataclass(frozen=True)
 class BDConfig:
     birth_fn: str
@@ -38,7 +47,7 @@ class BDConfig:
     hazard_fn: str
     hazard_params: Dict[str, float]
 
-    def load_models(self) -> tuple[bd.birth.BirthFunction, bd.death.HazardFunction]:
+    def load_models(self) -> tuple[bd.BirthFunction, bd.HazardFunction]:
         birth_fn = _load_cls(self.birth_fn)(**self.birth_params)
         hazard_fn = _load_cls(self.hazard_fn)(**self.hazard_params)
         return birth_fn, hazard_fn

From 236b26685ee586641e14e8f20dce1b8df6e57943 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 2 Dec 2023 21:37:40 +0900
Subject: [PATCH 099/337] Use point1/point2 representation for segment/capsule

---
 src/emevo/environments/circle_foraging.py |  2 +-
 src/emevo/environments/moderngl_vis.py    |  2 +-
 src/emevo/environments/phyjax2d.py        | 24 +++++++++--------------
 src/emevo/environments/phyjax2d_utils.py  | 20 +++++++++----------
 4 files changed, 21 insertions(+), 27 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 32e102f9..30c98d33 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -190,7 +190,7 @@ def _make_physics(
         xy = jnp.array(wall[0] + wall[1]) / 2
         position = Position(angle=angle, xy=xy)
         segments.append(position)
-        builder.add_segment(length=a2b.length, friction=0.2, elasticity=0.4)
+        builder.add_segment(p1=wall[0], p2=wall[1], friction=0.2, elasticity=0.4)
     seg_position = jax.tree_map(lambda *args: jnp.stack(args), *segments)
     seg_state = State.from_position(seg_position)
     # Prepare agents
diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index fc3d0429..22e72ef8 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -267,7 +267,7 @@ def _collect_circles(
 
 
 def _collect_static_lines(segment: Segment, state: State) -> NDArray:
-    a, b = segment.get_ab()
+    a, b = segment.point1, segment.point2
     a = state.p.transform(a)
     b = state.p.transform(b)
     return np.concatenate((a, b), axis=1).reshape(-1, 2)
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index c630fc02..c104d58e 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -324,19 +324,15 @@ def _effective_mass(
 
 @chex.dataclass
 class Capsule(Shape):
-    length: jax.Array
+    point1: jax.Array
+    point2: jax.Array
     radius: jax.Array
 
 
-def _length_to_points(length: jax.Array) -> tuple[jax.Array, jax.Array]:
-    a = jnp.stack((length * -0.5, length * 0.0), axis=-1)
-    b = jnp.stack((length * 0.5, length * 0.0), axis=-1)
-    return a, b
-
-
 @chex.dataclass
 class Segment(Shape):
-    length: jax.Array
+    point1: jax.Array
+    point2: jax.Array
 
     def to_capsule(self) -> Capsule:
         return Capsule(
@@ -345,13 +341,11 @@ def to_capsule(self) -> Capsule:
             elasticity=self.elasticity,
             friction=self.friction,
             rgba=self.rgba,
-            length=self.length,
-            radius=jnp.zeros_like(self.length),
+            point1=self.point1,
+            point2=self.point2,
+            radius=jnp.zeros(self.point1.shape[0]),
         )
 
-    def get_ab(self) -> tuple[jax.Array, jax.Array]:
-        return _length_to_points(self.length)
-
 
 @jax.vmap
 def _capsule_to_circle_impl(
@@ -363,7 +357,7 @@ def _capsule_to_circle_impl(
 ) -> Contact:
     # Move b_pos to capsule's coordinates
     pb = a_pos.inv_transform(b_pos.xy)
-    p1, p2 = _length_to_points(a.length)
+    p1, p2 = a.point1, a.point2
     edge = p2 - p1
     s1 = jnp.dot(pb - p1, edge)
     s2 = jnp.dot(p2 - pb, edge)
@@ -1075,7 +1069,7 @@ def segment_raycast(
     state: State,
 ) -> Raycast:
     d = p2 - p1
-    v1, v2 = _length_to_points(segment.length)
+    v1, v2 = segment.point1, segment.point2
     v1, v2 = state.p.transform(v1), state.p.transform(v2)
     e = v2 - v1
     eunit, length = normalize(e)
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index b7470c59..ffe07d73 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -14,7 +14,6 @@
     ShapeDict,
     Space,
     StateDict,
-    _length_to_points,
     _vmap_dot,
 )
 from emevo.vec2d import Vec2d, Vec2dLike
@@ -140,8 +139,9 @@ def add_circle(
     def add_capsule(
         self,
         *,
+        p1: Vec2d,
+        p2: Vec2d,
         radius: float,
-        length: float,
         density: float = 1.0,
         is_static: bool = False,
         friction: float = 0.8,
@@ -151,16 +151,16 @@ def add_capsule(
         _check_params_positive(
             friction=friction,
             radius=radius,
-            length=length,
             density=density,
             elasticity=elasticity,
         )
         mass, moment = _mass_and_moment(
-            *_capsule_mass(radius, length, density),
+            *_capsule_mass(radius, (p2 - p1).length, density),
             is_static,
         )
         capsule = Capsule(
-            length=jnp.array([length]),
+            point1=jnp.array(p1).reshape(1, 2),
+            point2=jnp.array(p2).reshape(1, 2),
             radius=jnp.array([radius]),
             mass=mass,
             moment=moment,
@@ -176,19 +176,20 @@ def add_capsule(
     def add_segment(
         self,
         *,
-        length: float,
+        p1: Vec2d,
+        p2: Vec2d,
         friction: float = 0.8,
         elasticity: float = 0.8,
         rgba: Color = _BLACK,
     ) -> None:
         _check_params_positive(
             friction=friction,
-            length=length,
             elasticity=elasticity,
         )
         mass, moment = _mass_and_moment(is_static=True)
         segment = Segment(
-            length=jnp.array([length]),
+            point1=jnp.array(p1).reshape(1, 2),
+            point2=jnp.array(p2).reshape(1, 2),
             mass=mass,
             moment=moment,
             elasticity=jnp.array([elasticity]),
@@ -307,12 +308,11 @@ def circle_overlap(
         overlap = jnp.logical_or(jnp.any(has_overlap), overlap)
 
     # Circle-segment overlap
-
     if stated.segment is not None and shaped.segment is not None:
         spos = stated.segment.p
         # Suppose that cpos.shape == (N, 2) and xy.shape == (2,)
         pb = spos.inv_transform(jnp.expand_dims(xy, axis=0))
-        p1, p2 = _length_to_points(shaped.segment.length)
+        p1, p2 = shaped.segment.point1, shaped.segment.point2
         edge = p2 - p1
         s1 = jnp.expand_dims(_vmap_dot(pb - p1, edge), axis=1)
         s2 = jnp.expand_dims(_vmap_dot(p2 - pb, edge), axis=1)

From 6f13a05079e00a238c9b24e3b10fcfddce41a961 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 4 Dec 2023 17:56:29 +0900
Subject: [PATCH 100/337] Chain segments (smooth segments)

---
 src/emevo/environments/circle_foraging.py |  23 ++---
 src/emevo/environments/phyjax2d.py        | 119 ++++++++++++++++------
 src/emevo/environments/phyjax2d_utils.py  |  59 +++++++++--
 3 files changed, 144 insertions(+), 57 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 30c98d33..508718c7 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -161,7 +161,7 @@ def _make_physics(
     agent_radius: float,
     food_radius: float,
     obstacles: list[tuple[Vec2d, Vec2d]] | None = None,
-) -> tuple[Physics, State]:
+) -> Physics:
     builder = SpaceBuilder(
         gravity=(0.0, 0.0),  # No gravity
         dt=dt,
@@ -181,18 +181,9 @@ def _make_physics(
             *coordinate.ylim,
             rounded_offset=np.floor(food_radius * 2 / (np.sqrt(2) - 1.0)),
         )
-    if obstacles is not None:
-        walls += obstacles
-    segments = []
-    for wall in walls:
-        a2b = wall[1] - wall[0]
-        angle = jnp.array(a2b.angle)
-        xy = jnp.array(wall[0] + wall[1]) / 2
-        position = Position(angle=angle, xy=xy)
-        segments.append(position)
-        builder.add_segment(p1=wall[0], p2=wall[1], friction=0.2, elasticity=0.4)
-    seg_position = jax.tree_map(lambda *args: jnp.stack(args), *segments)
-    seg_state = State.from_position(seg_position)
+    builder.add_chain_segments(chain_points=walls, friction=0.2, elasticity=0.4)
+    for obs in obstacles:
+        builder.add_segment(p1=obs[0], p2=obs[1], friction=0.2, elasticity=0.4)
     # Prepare agents
     for _ in range(n_max_agents):
         builder.add_circle(
@@ -211,7 +202,7 @@ def _make_physics(
             color=FOOD_COLOR,
             is_static=True,
         )
-    return builder.build(), seg_state
+    return builder.build()
 
 
 def _observe_closest(
@@ -367,7 +358,7 @@ def __init__(
         else:
             obs_list = obstacles
 
-        self._physics, self._segment_state = _make_physics(
+        self._physics = _make_physics(
             dt=dt,
             coordinate=self._coordinate,
             linear_damping=linear_damping,
@@ -656,7 +647,7 @@ def _initialize_physics_state(
         key: chex.PRNGKey,
     ) -> tuple[StateDict, LocatingState, LocatingState]:
         # Set segment
-        stated = self._physics.shaped.zeros_state().replace(segment=self._segment_state)
+        stated = self._physics.shaped.zeros_state()
         assert stated.circle is not None
 
         # Set is_active
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index c104d58e..a7a3dd25 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -2,7 +2,8 @@
 import functools
 import uuid
 from collections.abc import Sequence
-from typing import Any, Callable, Protocol
+from dataclasses import replace
+from typing import Any, Callable, NamedTuple, Protocol
 
 import chex
 import jax
@@ -98,7 +99,7 @@ def zeros(cls: type[Self], n: int) -> Self:
         return cls(angle=jnp.zeros((n,)), xy=jnp.zeros((n, 2)))
 
     @classmethod
-    def from_axy(cls: type[Self], axy: int) -> Self:
+    def from_axy(cls: type[Self], axy: jax.Array) -> Self:
         angle = jax.lax.squeeze(jax.lax.slice_in_dim(axy, 0, 1, axis=-1), (-1,))
         xy = jax.lax.slice_in_dim(axy, 1, 3, axis=-1)
         return cls(angle=angle, xy=xy)
@@ -126,6 +127,12 @@ def _get_xy(xy: jax.Array) -> tuple[jax.Array, jax.Array]:
     return jax.lax.squeeze(x, (-1,)), jax.lax.squeeze(y, (-1,))
 
 
+def _right_perp(xy: jax.Array) -> jax.Array:
+    x = jax.lax.slice_in_dim(xy, 0, 1, axis=-1)
+    y = jax.lax.slice_in_dim(xy, 1, 2, axis=-1)
+    return jnp.concatenate((y, -x))
+
+
 @chex.dataclass
 class Position(_PositionLike, PyTreeOps):
     angle: jax.Array  # Angular velocity (N, 1)
@@ -216,8 +223,8 @@ def apply_force_global(self, point: jax.Array, force: jax.Array) -> Self:
         chex.assert_equal_shape((self.f.xy, force))
         xy = self.f.xy + force
         angle = self.f.angle + jnp.cross(point - self.p.xy, force)
-        f = self.f.replace(xy=xy, angle=angle)
-        return self.replace(f=f)
+        f = replace(self.f, xy=xy, angle=angle)
+        return replace(self, f=f)
 
     def apply_force_local(self, point: jax.Array, force: jax.Array) -> Self:
         chex.assert_equal_shape((self.p.xy, point))
@@ -253,8 +260,7 @@ def _circle_to_circle_impl(
     a_contact = a_pos.xy + a2b_normal * a.radius
     b_contact = b_pos.xy - a2b_normal * b.radius
     pos = (a_contact + b_contact) * 0.5
-    # Filter penetration
-    penetration = jnp.where(isactive, penetration, jnp.ones_like(penetration) * -1)
+    penetration = jnp.where(isactive, penetration, -1.0)
     return Contact(
         pos=pos,
         normal=a2b_normal,
@@ -294,7 +300,7 @@ def update(self, new_contact: jax.Array) -> Self:
         continuing_contact = jnp.logical_and(self.contact, new_contact)
         pn = jnp.where(continuing_contact, self.pn, 0.0)
         pt = jnp.where(continuing_contact, self.pt, 0.0)
-        return self.replace(pn=pn, pt=pt, contact=new_contact)
+        return replace(self, pn=pn, pt=pt, contact=new_contact)
 
 
 def _vmap_dot(xy1: jax.Array, xy2: jax.Array) -> jax.Array:
@@ -333,18 +339,9 @@ class Capsule(Shape):
 class Segment(Shape):
     point1: jax.Array
     point2: jax.Array
-
-    def to_capsule(self) -> Capsule:
-        return Capsule(
-            mass=self.mass,
-            moment=self.moment,
-            elasticity=self.elasticity,
-            friction=self.friction,
-            rgba=self.rgba,
-            point1=self.point1,
-            point2=self.point2,
-            radius=jnp.zeros(self.point1.shape[0]),
-        )
+    is_smooth: jax.Array
+    ghost1: jax.Array
+    ghost2: jax.Array
 
 
 @jax.vmap
@@ -378,13 +375,67 @@ def _capsule_to_circle_impl(
     b_contact = pb - a2b_normal * b.radius
     pos = a_pos.transform((a_contact + b_contact) * 0.5)
     xy_zeros = jnp.zeros_like(b_pos.xy)
-    a2b_normal_rotated = a_pos.replace(xy=xy_zeros).transform(a2b_normal)
+    a2b_normal_rotated = replace(a_pos, xy=xy_zeros).transform(a2b_normal)
     # Filter penetration
-    penetration = jnp.where(isactive, penetration, jnp.ones_like(penetration) * -1)
     return Contact(
         pos=pos,
         normal=a2b_normal_rotated,
-        penetration=penetration,
+        penetration=jnp.where(isactive, penetration, -1.0),
+        elasticity=(a.elasticity + b.elasticity) * 0.5,
+        friction=(a.friction + b.friction) * 0.5,
+    )
+
+
+@jax.vmap
+def _segment_to_circle_impl(
+    a: Segment,
+    b: Circle,
+    a_pos: Position,
+    b_pos: Position,
+    isactive: jax.Array,
+) -> Contact:
+    # Move b_pos to segment's coordinates
+    pb = a_pos.inv_transform(b_pos.xy)
+    p1, p2 = a.point1, a.point2
+    edge = p2 - p1
+    s1 = jnp.dot(pb - p1, edge)
+    s2 = jnp.dot(p2 - pb, edge)
+    in_segment = jnp.logical_and(s1 > 0.0, s2 > 0.0)
+    ee = jnp.sum(jnp.square(edge), axis=-1, keepdims=True)
+    # Closest point
+    # s1 < 0: pb is left to the capsule
+    # s2 < 0: pb is right to the capsule
+    # else: pb is in between capsule
+    pa = jax.lax.select(
+        in_segment,
+        p1 + edge * s1 / ee,
+        jax.lax.select(s1 <= 0.0, p1, p2),
+    )
+    a2b_normal, dist = normalize(pb - pa)
+    penetration = b.radius - dist
+    a_contact = pa
+    b_contact = pb - a2b_normal * b.radius
+    pos = a_pos.transform((a_contact + b_contact) * 0.5)
+    xy_zeros = jnp.zeros_like(b_pos.xy)
+    a2b_normal_rotated = replace(a_pos, xy=xy_zeros).transform(a2b_normal)
+    # Filter penetration
+    collidable = jnp.dot(_right_perp(edge), pb - p1) >= 0.0
+    not_in_voronoi = jnp.logical_or(
+        jnp.logical_and(s1 <= 0.0, jnp.dot(a.ghost2 - p2, pb - p2) > 0.0),
+        jnp.logical_and(s2 <= 0.0, jnp.dot(p1 - a.ghost1, pb - p1) <= 0.0),
+    )
+    is_penetration_possible = jnp.logical_and(
+        isactive,
+        jnp.logical_or(
+            jnp.logical_not(a.is_smooth),
+            # collidable
+            jnp.logical_and(collidable, jnp.logical_not(not_in_voronoi)),
+        ),
+    )
+    return Contact(
+        pos=pos,
+        normal=a2b_normal_rotated,
+        penetration=jnp.where(is_penetration_possible, penetration, -1.0),
         elasticity=(a.elasticity + b.elasticity) * 0.5,
         friction=(a.friction + b.friction) * 0.5,
     )
@@ -402,16 +453,17 @@ class StateDict:
     static_capsule: State | None = None
 
     def concat(self) -> Self:
-        states = [s for s in self.values() if s is not None]
+        states = [s for s in self.values() if s is not None]  # type: ignore
         return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *states)
 
-    def _get(self, name: str, state: State) -> State | None:
-        if self[name] is None:
+    def _get(self, name: str, statec: State) -> State | None:
+        state: State | None = self[name]  # type: ignore
+        if state is None:
             return None
         else:
             start = _offset(self, name)
-            end = start + self[name].p.batch_size()
-            return state.get_slice(jnp.arange(start, end))
+            end = start + state.p.batch_size()
+            return statec.get_slice(jnp.arange(start, end))
 
     def update(self, statec: State) -> Self:
         circle = self._get("circle", statec)
@@ -567,8 +619,8 @@ def _segment_to_circle(ci: ContactIndices, stated: StateDict) -> Contact:
     pos2 = jax.tree_map(lambda arr: arr[ci.index2], stated.circle.p)
     is_active1 = stated.segment.is_active[ci.index1]
     is_active2 = stated.circle.is_active[ci.index2]
-    return _capsule_to_circle_impl(
-        ci.shape1.to_capsule(),
+    return _segment_to_circle_impl(
+        ci.shape1,
         ci.shape2,
         pos1,
         pos2,
@@ -576,7 +628,8 @@ def _segment_to_circle(ci: ContactIndices, stated: StateDict) -> Contact:
     )
 
 
-_CONTACT_FUNCTIONS = {
+_CONTACT_FN = Callable[[ContactIndices, StateDict], Contact]
+_CONTACT_FUNCTIONS: dict[tuple[str, str], _CONTACT_FN] = {
     ("circle", "circle"): _circle_to_circle,
     ("circle", "static_circle"): _circle_to_static_circle,
     ("capsule", "circle"): _capsule_to_circle,
@@ -595,6 +648,7 @@ class Space:
     n_velocity_iter: int = 6
     n_position_iter: int = 2
     linear_slop: float = 0.005
+    speculative_distance: float = 0.02
     max_linear_correction: float = 0.2
     allowed_penetration: float = 0.005
     bounce_threshold: float = 1.0
@@ -649,7 +703,8 @@ def check_contacts(self, stated: StateDict) -> Contact:
         for (n1, n2), fn in _CONTACT_FUNCTIONS.items():
             ci = self._ci.get((n1, n2), None)
             if ci is not None:
-                contacts.append(fn(ci, stated))
+                contact = fn(ci, stated)
+                contacts.append(contact)
         return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *contacts)
 
     def n_possible_contacts(self) -> int:
@@ -1012,7 +1067,7 @@ def step(
     contact = space.check_contacts(stated.update(state))
     v, p, solver = solve_constraints(
         space,
-        solver.update(contact.penetration >= 0),
+        solver.update(contact.penetration >= space.speculative_distance),
         state.p,
         state.v,
         contact,
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index ffe07d73..47e46a17 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -187,9 +187,15 @@ def add_segment(
             elasticity=elasticity,
         )
         mass, moment = _mass_and_moment(is_static=True)
+        point1 = jnp.array(p1).reshape(1, 2)
+        point2 = jnp.array(p2).reshape(1, 2)
         segment = Segment(
             point1=jnp.array(p1).reshape(1, 2),
             point2=jnp.array(p2).reshape(1, 2),
+            is_smooth=jnp.array([False]),
+            # Fake ghosts
+            ghost1=point1,
+            ghost2=point2,
             mass=mass,
             moment=moment,
             elasticity=jnp.array([elasticity]),
@@ -198,6 +204,39 @@ def add_segment(
         )
         self.segments.append(segment)
 
+    def add_chain_segments(
+        self,
+        *,
+        chain_points: list[tuple[Vec2d, Vec2d]],
+        friction: float = 0.8,
+        elasticity: float = 0.8,
+        rgba: Color = _BLACK,
+    ) -> None:
+        _check_params_positive(
+            friction=friction,
+            elasticity=elasticity,
+        )
+        mass, moment = _mass_and_moment(is_static=True)
+        n_points = len(chain_points)
+        for i in range(n_points):
+            g1 = chain_points[i - 1][0]
+            p1, p2 = chain_points[i]
+            g2 = chain_points[(i + 1) % n_points][1]
+            segment = Segment(
+                point1=jnp.array(p1).reshape(1, 2),
+                point2=jnp.array(p2).reshape(1, 2),
+                is_smooth=jnp.array([True]),
+                # Fake ghosts
+                ghost1=jnp.array(g1).reshape(1, 2),
+                ghost2=jnp.array(g2).reshape(1, 2),
+                mass=mass,
+                moment=moment,
+                elasticity=jnp.array([elasticity]),
+                friction=jnp.array([friction]),
+                rgba=jnp.array(rgba).reshape(1, 4),
+            )
+            self.segments.append(segment)
+
     def build(self) -> Space:
         def concat_or(sl: list[Shape]) -> Shape | None:
             if len(sl) > 0:
@@ -241,12 +280,13 @@ def make_approx_circle(
     radius: float,
     n_lines: int = 32,
 ) -> list[tuple[Vec2d, Vec2d]]:
+    """Make circle. Points are ordered clockwith."""
     unit = np.pi * 2 / n_lines
     lines = []
     t0 = Vec2d(radius, 0.0)
-    for i in range(n_lines):
-        start = center + t0.rotated(unit * i)
-        end = center + t0.rotated(unit * (i + 1))
+    for i in reversed(range(n_lines)):
+        start = center + t0.rotated(unit * (i + 1))
+        end = center + t0.rotated(unit * i)
         lines.append((start, end))
     return lines
 
@@ -258,6 +298,7 @@ def make_square(
     ymax: float,
     rounded_offset: float | None = None,
 ) -> list[tuple[Vec2d, Vec2d]]:
+    """Make square. Points are ordered clockwith."""
     p1 = Vec2d(xmin, ymin)
     p2 = Vec2d(xmin, ymax)
     p3 = Vec2d(xmax, ymax)
@@ -269,12 +310,12 @@ def make_square(
             offset = s2end.normalized() * rounded_offset
             stop = end - offset
             lines.append((start + offset, stop))
-            stop2end = end - stop
-            center = stop + stop2end.rotated(-np.pi / 2)
-            for i in range(4):
-                start = center + stop2end.rotated(np.pi / 8 * i)
-                end = center + stop2end.rotated(np.pi / 8 * (i + 1))
-                lines.append((start, end))
+            # Center of the rounded corner
+            center = stop + offset.rotated(-np.pi / 2)
+            for i in reversed(range(4)):
+                r_start = center + offset.rotated(np.pi / 8 * (i + 1))
+                r_end = center + offset.rotated(np.pi / 8 * i)
+                lines.append((r_start, r_end))
     else:
         for start, end in [(p1, p2), (p2, p3), (p3, p4), (p4, p1)]:
             lines.append((start, end))

From 0d3876e2f6c0d3569b7b2fabb2f22ffe8520ffac Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 7 Dec 2023 17:01:57 +0900
Subject: [PATCH 101/337] Script for plotting birth dan death functions

---
 config/20230530-a035-e020.toml |  14 +++
 noxfile.py                     |  13 ++-
 pyproject.toml                 |   2 +-
 requirements/scripts.in        |   3 +
 scripts/plot_bd_models.py      | 163 +++++++++++++++++++++++++++++++++
 src/emevo/birth_and_death.py   |  25 ++---
 6 files changed, 206 insertions(+), 14 deletions(-)
 create mode 100644 config/20230530-a035-e020.toml
 create mode 100644 requirements/scripts.in
 create mode 100644 scripts/plot_bd_models.py

diff --git a/config/20230530-a035-e020.toml b/config/20230530-a035-e020.toml
new file mode 100644
index 00000000..f862b695
--- /dev/null
+++ b/config/20230530-a035-e020.toml
@@ -0,0 +1,14 @@
+birth_fn = "emevo.birth_and_death.EnergyLogisticBirth"
+hazard_fn = "emevo.birth_and_death.ELGompertzHazard"
+
+[hazard_params]
+alpha = 0.35
+alpha_age = 1e-6
+beta = 3e-5
+scale = 0.1
+e0 = 0.0
+
+[birth_params]
+alpha = 0.1
+scale = 2e-4
+e0 = 20.0.
\ No newline at end of file
diff --git a/noxfile.py b/noxfile.py
index 97592301..43469dd7 100644
--- a/noxfile.py
+++ b/noxfile.py
@@ -88,9 +88,20 @@ def ipython(session: nox.Session) -> None:
     session.run("python", "-m", "IPython")
 
 
+@nox.session(reuse_venv=True)
+def script(session: nox.Session) -> None:
+    """Run scripts"""
+    _sync(session, "requirements/scripts.txt")
+    DEFAULT = "scripts/plot_bd_models.py"
+    if 0 < len(session.posargs) and session.posargs[0].endswith(".py"):
+        session.run("python", *session.posargs)
+    else:
+        session.run("python", DEFAULT, *session.posargs)
+
+
 @nox.session(reuse_venv=True)
 def smoke(session: nox.Session) -> None:
-    """Run a smoke test"""
+    """Run smoke tests"""
     _sync(session, "requirements/smoke.txt")
     DEFAULT = "smoke-tests/circle_loop.py"
     if 0 < len(session.posargs) and session.posargs[0].endswith(".py"):
diff --git a/pyproject.toml b/pyproject.toml
index 0adc4ebd..f9890c13 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -25,7 +25,7 @@ dependencies = [
     "moderngl >= 5.6",
     "moderngl-window >= 2.4",
     "jax >= 0.4",
-    "pyserde >= 0.12",
+    "pyserde[toml] >= 0.12",
     "optax >= 0.1",
 ]
 dynamic = ["version"]
diff --git a/requirements/scripts.in b/requirements/scripts.in
new file mode 100644
index 00000000..fdd6aec5
--- /dev/null
+++ b/requirements/scripts.in
@@ -0,0 +1,3 @@
+-e .
+matplotlib
+typer
\ No newline at end of file
diff --git a/scripts/plot_bd_models.py b/scripts/plot_bd_models.py
new file mode 100644
index 00000000..d35388cb
--- /dev/null
+++ b/scripts/plot_bd_models.py
@@ -0,0 +1,163 @@
+from pathlib import Path
+
+import matplotlib as mpl
+import typer
+from matplotlib import pyplot as plt
+from serde import toml
+
+from emevo.exp_utils import BDConfig
+from emevo.plotting import (
+    show_params_text,
+    vis_birth,
+    vis_birth_2d,
+    vis_expected_n_children,
+    vis_hazard,
+    vis_lifetime,
+    vis_survivorship,
+)
+
+
+def plot_bd_models(
+    config: Path = Path("config/20230530-a035-e020.toml"),
+    age_max: int = 200000,
+    energy_max: float = 40,
+    survivorship_energy: float = 10.0,
+    n_discr: int = 100,
+    yes: bool = typer.Option(False, help="Skip all yes/no prompts"),
+    horizontal: bool = typer.Option(
+        False,
+        help="Use horizontal order for multiple figures",
+    ),
+    noparam: bool = typer.Option(False, help="Don't show parameters"),
+    nolifespan: bool = typer.Option(False, help="Don't show lifespan"),
+    simpletitle: bool = typer.Option(False, help="Make title simple"),
+    birth2d: bool = typer.Option(False, help="Make 2D plot for birth rate"),
+) -> None:
+    try:
+        import PySide6
+
+        mpl.use("QtAgg")
+    except ImportError:
+        mpl.use("TkAgg")
+
+    with config.open("r") as f:
+        bd_config = toml.from_toml(BDConfig, f.read())
+
+    birth_model, hazard_model = bd_config.load_models()
+    if yes or typer.confirm("Plot hazard model?"):
+        if horizontal:
+            fig = plt.figure(figsize=(10, 6))
+            ax1 = fig.add_subplot(121, projection="3d")
+            ax2 = fig.add_subplot(122, projection="3d")
+        else:
+            fig = plt.figure(figsize=(5, 10))
+            ax1 = fig.add_subplot(211, projection="3d")
+            ax2 = fig.add_subplot(212, projection="3d")
+        if simpletitle:
+            ax1.set_title("Hazard function")  # type: ignore
+            ax2.set_title("Survival function")  # type: ignore
+        else:
+            ax1.set_title(f"{type(hazard_model).__name__} Hazard function")  # type: ignore
+            ax2.set_title(f"{type(hazard_model).__name__} Survival function")  # type: ignore
+        vis_hazard(
+            ax1,
+            hazard_fn=hazard_model,
+            age_max=age_max,
+            energy_max=energy_max,
+            n_discr=n_discr,
+            method="hazard",
+            shown_params=None if noparam else bd_config.hazard_params,
+        )
+        vis_hazard(
+            ax2,
+            hazard_fn=hazard_model,
+            age_max=age_max,
+            energy_max=energy_max,
+            n_discr=n_discr,
+            method="survival",
+        )
+        plt.show()
+
+    if yes or typer.confirm("Plot birth model?"):
+        fig = plt.figure(figsize=(6, 4))
+        if birth2d:
+            ax = fig.add_subplot(111)
+        else:
+            ax = fig.add_subplot(111, projection="3d")
+        if simpletitle:
+            ax.set_title(f"Birth function")  # type: ignore
+        else:
+            ax.set_title(f"{type(birth_model).__name__} Birth function")  # type: ignore
+        if birth2d:
+            vis_birth_2d(
+                ax,
+                birth_fn=birth_model,
+                energy_max=energy_max,
+                initial=True,
+            )
+        else:
+            vis_birth(
+                ax,
+                birth_fn=birth_model,
+                age_max=age_max,
+                energy_max=energy_max,
+                n_discr=n_discr,
+                initial=True,
+                shown_params=None if noparam else bd_config.birth_params,
+            )
+        plt.show()
+
+    if yes or typer.confirm("Plot survivor ship curve?"):
+        fig = plt.figure(figsize=(5, 10))
+        ax = fig.add_subplot(111)
+        ax.set_title(
+            f"{type(birth_model).__name__} Survivor ship when energy={survivorship_energy}"
+        )
+        vis_survivorship(ax=ax, hazard_fn=hazard_model, age_max=age_max, initial=True)
+        plt.show()
+
+    if yes or typer.confirm("Plot expected num. of children?"):
+        if nolifespan:
+            fig = plt.figure(figsize=(6, 4))
+            ax1 = None
+            ax2 = fig.add_subplot(111)
+        elif horizontal:
+            fig = plt.figure(figsize=(10, 5))
+            ax1 = fig.add_subplot(121)
+            ax2 = fig.add_subplot(122)
+        else:
+            fig = plt.figure(figsize=(6, 10))
+            ax1 = fig.add_subplot(211)
+            ax2 = fig.add_subplot(212)
+        if simpletitle:
+            name = ""
+        else:
+            name = f"{type(hazard_model).__name__} & {type(birth_model).__name__} "
+        if ax1 is not None:
+            ax1.set_title(f"{name}Expected Lifetime")  # type: ignore
+            vis_lifetime(
+                ax1,
+                hazard_fn=hazard_model,
+                energy_max=energy_max,
+                n_discr=n_discr,
+            )
+            if not noparam:
+                params = bd_config.hazard_params | {
+                    f"birth_{key}": value
+                    for key, value in bd_config.birth_params.items()
+                }
+                show_params_text(ax1, params, columns=2)
+
+        ax2.set_title(f"{name}Expected Num. of children")  # type: ignore
+        vis_expected_n_children(
+            ax2,
+            birth_fn=birth_model,
+            hazard_fn=hazard_model,
+            energy_max=energy_max,
+            n_discr=n_discr,
+        )
+        plt.show()
+
+
+if __name__ == "__main__":
+    typer.run(plot_bd_models)
diff --git a/src/emevo/birth_and_death.py b/src/emevo/birth_and_death.py
index 5d1db303..f73b36dc 100644
--- a/src/emevo/birth_and_death.py
+++ b/src/emevo/birth_and_death.py
@@ -169,8 +169,8 @@ class EnergyLogisticBirth(BirthFunction):
     scale: float = 0.1
     e0: float = 8.0
 
-    def __call__(self, _age: jax.Array, energy: jax.Array) -> jax.Array:
-        del _age
+    def __call__(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        del age
         return self.scale / (1.0 + self.alpha * jnp.exp(self.e0 - energy))
 
     def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
@@ -178,18 +178,16 @@ def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         return age * self(age, energy)
 
 
-N = 100000
-
-
 def compute_cumulative_hazard(
     hazard: HazardFunction,
     *,
     energy: float = 10.0,
     max_age: float = 1e6,
+    n: int = 100000,
 ) -> float:
     """Compute cumulative hazard using numeric integration"""
-    age = jnp.linspace(0.0, max_age, N)
-    return trapezoid(y=hazard(age, jnp.ones(N) * energy), x=age)
+    age = jnp.linspace(0.0, max_age, n)
+    return trapezoid(y=hazard(age, jnp.ones(n) * energy), x=age)
 
 
 def compute_cumulative_survival(
@@ -197,10 +195,11 @@ def compute_cumulative_survival(
     *,
     energy: float = 10.0,
     max_age: float = 1e6,
+    n: int = 100000,
 ) -> float:
     """Compute cumulative survival rate using numeric integration"""
-    age = jnp.linspace(0.0, max_age, N)
-    return trapezoid(y=hazard.survival(age, jnp.ones(N) * energy), x=age)
+    age = jnp.linspace(0.0, max_age, n)
+    return trapezoid(y=hazard.survival(age, jnp.ones(n) * energy), x=age)
 
 
 def compute_stable_birth_rate(
@@ -208,9 +207,10 @@ def compute_stable_birth_rate(
     *,
     energy: float = 10.0,
     max_age: float = 1e6,
+    n: int = 100000,
 ) -> float:
     """Compute cumulative survival rate using numeric integration"""
-    cumsuv = compute_cumulative_survival(hazard, energy=energy, max_age=max_age)
+    cumsuv = compute_cumulative_survival(hazard, energy=energy, max_age=max_age, n=n)
     return 1.0 / cumsuv
 
 
@@ -220,9 +220,10 @@ def compute_expected_n_children(
     hazard: HazardFunction,
     max_age: float = 1e6,
     energy: float = 10.0,
+    n: int = 100000,
 ) -> float:
-    age = jnp.linspace(0.0, max_age, N)
-    energy_arr = jnp.ones(N) * energy
+    age = jnp.linspace(0.0, max_age, n)
+    energy_arr = jnp.ones(n) * energy
     s = hazard.survival(age, energy_arr)
     b = birth(age, energy_arr)
     return trapezoid(y=s * b, x=age)

From 762dfa6c896739b6e483e452a3ca2b224edd6cf1 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 8 Dec 2023 18:56:30 +0900
Subject: [PATCH 102/337] Fix some pyright errors

---
 src/emevo/env.py                          |   8 +-
 src/emevo/environments/circle_foraging.py |  58 ++++----
 src/emevo/environments/env_utils.py       |  45 ++++---
 src/emevo/environments/moderngl_vis.py    |  14 +-
 src/emevo/environments/phyjax2d.py        | 153 +++++++++++++---------
 src/emevo/environments/phyjax2d_utils.py  |  40 +++---
 src/emevo/rl/ppo_normal.py                |  16 +--
 src/emevo/spaces.py                       |  55 +++-----
 src/emevo/status.py                       |   7 +-
 tests/test_observe.py                     |  17 ++-
 tests/test_placement.py                   |  21 +--
 11 files changed, 240 insertions(+), 194 deletions(-)

diff --git a/src/emevo/env.py b/src/emevo/env.py
index 01111a5f..706cb12f 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -35,7 +35,7 @@ def activate(
         unique_id = self.unique_id.at[index].set(uid)
         birthtime = self.birthtime.at[index].set(step)
         generation = self.generation.at[index].set(parent_gen + 1)
-        return self.replace(
+        return Profile(
             birthtime=birthtime,
             generation=generation,
             unique_id=unique_id,
@@ -45,7 +45,7 @@ def deactivate(self, index: Index) -> Self:
         unique_id = self.unique_id.at[index].set(-1)
         birthtime = self.birthtime.at[index].set(-1)
         generation = self.generation.at[index].set(-1)
-        return self.replace(
+        return Profile(
             birthtime=birthtime,
             generation=generation,
             unique_id=unique_id,
@@ -122,7 +122,7 @@ def step(self, state: STATE, action: ArrayLike) -> tuple[STATE, TimeStep[OBS]]:
         pass
 
     @abc.abstractmethod
-    def activate(self, state: STATE, parent_gen: int | jax.Array) -> tuple[STATE, bool]:
+    def activate(self, state: STATE, parent_gen: jax.Array) -> tuple[STATE, jax.Array]:
         """
         Mark an agent or some agents active.
         This method fails if there isn't enough space, returning (STATE, False).
@@ -141,6 +141,6 @@ def deactivate(self, state: STATE, index: Index) -> STATE:
         pass
 
     @abc.abstractmethod
-    def visualizer(self, headless: bool = False, **kwargs) -> Visualizer:
+    def visualizer(self, state: STATE, **kwargs) -> Visualizer:
         """Create a visualizer for the environment"""
         pass
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 508718c7..f1206072 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -3,6 +3,8 @@
 import enum
 import functools
 import warnings
+from collections.abc import Iterable
+from dataclasses import replace
 from typing import Any, Callable, Literal, NamedTuple
 
 import chex
@@ -160,7 +162,7 @@ def _make_physics(
     n_max_foods: int,
     agent_radius: float,
     food_radius: float,
-    obstacles: list[tuple[Vec2d, Vec2d]] | None = None,
+    obstacles: Iterable[tuple[Vec2d, Vec2d]] = (),
 ) -> Physics:
     builder = SpaceBuilder(
         gravity=(0.0, 0.0),  # No gravity
@@ -211,10 +213,6 @@ def _observe_closest(
     p2: jax.Array,
     stated: StateDict,
 ) -> jax.Array:
-    assert shaped.circle is not None and stated.circle is not None
-    assert shaped.static_circle is not None and stated.static_circle is not None
-    assert shaped.segment is not None and stated.segment is not None
-
     def cr(shape: Circle, state: State) -> Raycast:
         return circle_raycast(0.0, 1.0, p1, p2, shape, state)
 
@@ -243,6 +241,7 @@ def _get_sensors(
     sensor_length: float,
     stated: StateDict,
 ) -> tuple[jax.Array, jax.Array]:
+    assert shaped.circle is not None and stated.circle is not None
     radius = shaped.circle.radius
     p1 = jnp.stack((jnp.zeros_like(radius), radius), axis=1)  # (N, 2)
     p1 = jnp.repeat(p1, n_sensors, axis=0)  # (N x M, 2)
@@ -278,7 +277,7 @@ def nstep(
 ) -> tuple[StateDict, VelocitySolver, jax.Array]:
     def body(
         stated_and_solver: tuple[StateDict, VelocitySolver],
-        _zero: jax.Array,
+        _: jax.Array,
     ) -> tuple[tuple[StateDict, VelocitySolver], jax.Array]:
         state, solver, contact = physics_step(space, *stated_and_solver)
         return (state, solver), contact.penetration >= 0.0
@@ -500,15 +499,6 @@ def _make_agent_loc_fn(
             },
         )
 
-    def set_food_num_fn(self, food_num_fn: str | tuple | ReprNumFn) -> None:
-        self._food_num_fn = self._make_food_num_fn(food_num_fn)
-
-    def set_food_loc_fn(self, food_loc_fn: str | tuple | LocatingFn) -> None:
-        self._food_loc_fn = self._make_food_loc_fn(food_loc_fn)
-
-    def set_agent_loc_fn(self, agent_loc_fn: str | tuple | LocatingFn) -> None:
-        self._agent_loc_fn = self._make_agent_loc_fn(agent_loc_fn)
-
     def step(
         self,
         state: CFState,
@@ -523,7 +513,7 @@ def step(
         circle = state.physics.circle
         circle = circle.apply_force_local(self._act_p1, f1)
         circle = circle.apply_force_local(self._act_p2, f2)
-        stated = state.physics.replace(circle=circle)
+        stated = replace(state.physics, circle=circle)
         # Step physics simulator
         stated, solver, nstep_contacts = nstep(
             self._n_physics_iter,
@@ -564,16 +554,24 @@ def step(
             state.food_num,
             state.food_loc,
         )
-        state = state.replace(
-            key=key,
+        state = CFState(
             physics=stated,
             solver=solver,
             food_num=food_num,
+            agent_loc=state.agent_loc,
             food_loc=food_loc,
+            key=key,
+            step=state.step + 1,
+            profile=state.profile,
+            n_born_agents=state.n_born_agents,
         )
         return state, timestep
 
-    def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool]:
+    def activate(
+        self,
+        state: CFState,
+        parent_gen: jax.Array,
+    ) -> tuple[CFState, jax.Array]:
         circle = state.physics.circle
         key, place_key = jax.random.split(state.key)
         new_xy, ok = self._place_agent(key=place_key, stated=state.physics)
@@ -586,14 +584,18 @@ def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool
         angle = jnp.where(place, 0.0, circle.p.angle)
         p = Position(angle=angle, xy=xy)
         is_active = jnp.logical_or(place, circle.is_active)
-        physics = state.physics.replace(circle=circle.replace(p=p, is_active=is_active))
+        physics = replace(
+            state.physics,
+            circle=replace(circle, p=p, is_active=is_active),
+        )
         profile = state.profile.activate(
             place,
             parent_gen,
             state.n_born_agents,
             state.step,
         )
-        new_state = state.replace(
+        new_state = replace(
+            state,
             physics=physics,
             profile=profile,
             n_born_agents=state.n_born_agents + jnp.sum(place),
@@ -603,15 +605,15 @@ def activate(self, state: CFState, parent_gen: jax.Array) -> tuple[CFState, bool
 
     def deactivate(self, state: CFState, index: Index) -> CFState:
         p_xy = state.physics.circle.p.xy.at[index].set(self._invisible_xy)
-        p = state.physics.circle.p.replace(xy=p_xy)
+        p = replace(state.physics.circle.p, xy=p_xy)
         v_xy = state.physics.circle.v.xy.at[index].set(0.0)
         v_angle = state.physics.circle.v.angle.at[index].set(0.0)
         v = Velocity(angle=v_angle, xy=v_xy)
         is_active = state.physics.circle.is_active.at[index].set(False)
-        circle = state.physics.circle.replace(p=p, v=v, is_active=is_active)
-        physics = state.physics.replace(circle=circle)
+        circle = replace(state.physics.circle, p=p, v=v, is_active=is_active)
+        physics = replace(state.physics, circle=circle)
         profile = state.profile.deactivate(index)
-        return state.replace(physics=physics, profile=profile)
+        return replace(state, physics=physics, profile=profile)
 
     def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
         physics, agent_loc, food_loc = self._initialize_physics_state(key)
@@ -735,9 +737,9 @@ def _remove_and_reproduce_foods(
             xy,
         )
         is_active = jnp.logical_or(is_active, place)
-        p = sd.static_circle.p.replace(xy=xy)
-        sc = sd.static_circle.replace(p=p, is_active=is_active)
-        sd = sd.replace(static_circle=sc)
+        p = replace(sd.static_circle.p, xy=xy)
+        sc = replace(sd.static_circle, p=p, is_active=is_active)
+        sd = replace(sd, static_circle=sc)
         incr = jnp.sum(place)
         return sd, food_num.recover(incr), food_loc.increment(incr)
 
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index 01fa73b1..24600fa1 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -3,7 +3,7 @@
 
 import dataclasses
 import enum
-from typing import Any, Callable, Protocol
+from typing import Any, Callable, Protocol, cast
 
 import chex
 import jax
@@ -25,10 +25,10 @@ def appears(self) -> jax.Array:
         return (self.internal - self.current) >= 1.0
 
     def eaten(self, n: int | jax.Array) -> Self:
-        return self.replace(current=self.current - n, internal=self.internal - n)
+        return FoodNumState(current=self.current - n, internal=self.internal - n)
 
     def recover(self, n: int | jax.Array = 1) -> Self:
-        return self.replace(current=self.current + n)
+        return dataclasses.replace(self, current=self.current + n)
 
 
 class ReprNumFn(Protocol):
@@ -44,7 +44,10 @@ class ReprNumConstant:
 
     def __call__(self, state: FoodNumState) -> FoodNumState:
         # Do nothing here
-        return state.replace(internal=jnp.array(self.initial, dtype=jnp.float32))
+        return dataclasses.replace(
+            state,
+            internal=jnp.array(self.initial, dtype=jnp.float32),
+        )
 
 
 @dataclasses.dataclass(frozen=True)
@@ -56,7 +59,7 @@ def __call__(self, state: FoodNumState) -> FoodNumState:
         # Increase the number of foods by dn_dt
         internal = jnp.fmax(state.current, state.internal)
         internal = jnp.clip(internal + self.dn_dt, a_max=float(self.initial))
-        return state.replace(internal=internal)
+        return dataclasses.replace(state, internal=internal)
 
 
 @dataclasses.dataclass(frozen=True)
@@ -68,7 +71,7 @@ class ReprNumLogistic:
     def __call__(self, state: FoodNumState) -> FoodNumState:
         internal = jnp.fmax(state.current, state.internal)
         dn_dt = self.growth_rate * internal * (1 - internal / self.capacity)
-        return state.replace(internal=internal + dn_dt)
+        return dataclasses.replace(state, internal=internal + dn_dt)
 
 
 class ReprNum(str, enum.Enum):
@@ -97,14 +100,16 @@ def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn, FoodNumState]:
             fn = ReprNumLogistic(*args, **kwargs)
         else:
             raise AssertionError("Unreachable")
-        return fn, state
+        return cast(ReprNumFn, fn), state
 
 
 class Coordinate(Protocol):
     def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]:
         ...
 
-    def contains_circle(self, center: jax.Array, radius: jax.Array) -> jax.Array:
+    def contains_circle(
+        self, center: jax.Array, radius: jax.Array | float
+    ) -> jax.Array:
         ...
 
     def uniform(self, key: chex.PRNGKey) -> jax.Array:
@@ -121,7 +126,9 @@ def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]:
         r = self.radius
         return (cx - r, cx + r), (cy - r, cy + r)
 
-    def contains_circle(self, center: jax.Array, radius: jax.Array) -> jax.Array:
+    def contains_circle(
+        self, center: jax.Array, radius: jax.Array | float
+    ) -> jax.Array:
         a2b = center - jnp.array(self.center)
         distance = jnp.linalg.norm(a2b, ord=2)
         return distance + radius <= self.radius
@@ -148,7 +155,9 @@ class SquareCoordinate(Coordinate):
     def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]:
         return self.xlim, self.ylim
 
-    def contains_circle(self, center: jax.Array, radius: jax.Array) -> jax.Array:
+    def contains_circle(
+        self, center: jax.Array, radius: jax.Array | float
+    ) -> jax.Array:
         xmin, xmax = self.xlim
         ymin, ymax = self.ylim
         low = jnp.array([xmin, ymin]) + radius
@@ -168,8 +177,8 @@ class LocatingState:
     n_produced: jax.Array
     n_trial: jax.Array
 
-    def increment(self, n: int = 1) -> Self:
-        return self.replace(n_produced=self.n_produced + n, n_trial=self.n_trial + 1)
+    def increment(self, n: jax.Array | int = 1) -> Self:
+        return LocatingState(n_produced=self.n_produced + n, n_trial=self.n_trial + 1)
 
 
 LocatingFn = Callable[[chex.PRNGKey, LocatingState], jax.Array]
@@ -207,7 +216,7 @@ def loc_gaussian(mean: ArrayLike, stddev: ArrayLike) -> LocatingFn:
     mean_a = jnp.array(mean)
     std_a = jnp.array(stddev)
     shape = mean_a.shape
-    return lambda key, _state: jax.random.normal(key, shape=shape) * std_a + mean_a
+    return lambda key, _: jax.random.normal(key, shape=shape) * std_a + mean_a
 
 
 def loc_gaussian_mixture(
@@ -220,7 +229,7 @@ def loc_gaussian_mixture(
     probs_a = jnp.array(probs)
     n = probs_a.shape[0]
 
-    def sample(key: chex.PRNGKey, _state: LocatingState) -> jax.Array:
+    def sample(key: chex.PRNGKey, _: LocatingState) -> jax.Array:
         k1, k2 = jax.random.split(key)
         i = jax.random.choice(k1, n, p=probs_a)
         mi, si = mean_a[i], stddev_a[i]
@@ -230,7 +239,7 @@ def sample(key: chex.PRNGKey, _state: LocatingState) -> jax.Array:
 
 
 def loc_uniform(coordinate: Coordinate) -> LocatingFn:
-    return lambda key, _state: coordinate.uniform(key)
+    return lambda key, _: coordinate.uniform(key)
 
 
 class LocPeriodic:
@@ -238,7 +247,7 @@ def __init__(self, *locations: ArrayLike) -> None:
         self._locations = jnp.array(locations)
         self._n = self._locations.shape[0]
 
-    def __call__(self, _key: chex.PRNGKey, state: LocatingState) -> jax.Array:
+    def __call__(self, _: chex.PRNGKey, state: LocatingState) -> jax.Array:
         return self._locations[state.n_trial % self._n]
 
 
@@ -277,7 +286,7 @@ def place(
     key: chex.PRNGKey,
     shaped: ShapeDict,
     stated: StateDict,
-) -> tuple[jax.Array, bool]:
+) -> tuple[jax.Array, jax.Array]:
     """Returns `[inf, inf]` if it fails"""
     keys = jax.random.split(key, n_trial)
     vmap_loc_fn = jax.vmap(loc_fn, in_axes=(0, None))
@@ -290,7 +299,5 @@ def place(
         radius,
     )
     ok = jnp.logical_and(contains_fn(locations, radius), jnp.logical_not(overlap))
-    # print(locations)
-    # print(overlap)
     mask = jnp.expand_dims(first_true(ok), axis=1)
     return jnp.sum(mask * locations, axis=0), jnp.any(ok)
diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index 22e72ef8..a50f6a6a 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -6,6 +6,7 @@
 
 from typing import Any, Callable, ClassVar, Protocol
 
+import jax.numpy as jnp
 import moderngl as mgl
 import moderngl_window as mglw
 import numpy as np
@@ -274,9 +275,9 @@ def _collect_static_lines(segment: Segment, state: State) -> NDArray:
 
 
 def _collect_heads(circle: Circle, state: State) -> NDArray:
-    y = np.array(circle.radius)
-    x = np.zeros_like(y)
-    p1, p2 = np.stack((x, y * 0.8), axis=1), np.stack((x, y * 1.2), axis=1)
+    y = jnp.array(circle.radius)
+    x = jnp.zeros_like(y)
+    p1, p2 = jnp.stack((x, y * 0.8), axis=1), jnp.stack((x, y * 1.2), axis=1)
     p1, p2 = state.p.transform(p1), state.p.transform(p2)
     return np.concatenate((p1, p2), axis=1).reshape(-1, 2)
 
@@ -374,7 +375,11 @@ def __init__(
             )
 
             def collect_sensors(stated: StateDict) -> NDArray:
-                return np.concatenate(sensor_fn(stated=stated), axis=1).reshape(-1, 2)
+                sensors = np.concatenate(
+                    sensor_fn(stated=stated),  # type: ignore
+                    axis=1,
+                )
+                return sensors.reshape(-1, 2).astype(jnp.float32)
 
             self._sensors = SegmentVA(
                 ctx=context,
@@ -410,7 +415,6 @@ def _make_gl_program(
         **kwargs: NDArray,
     ) -> mgl.Program:
         self._context.enable(mgl.PROGRAM_POINT_SIZE | mgl.BLEND)
-        self._context.blend_func = mgl.DEFAULT_BLENDING
         prog = self._context.program(
             vertex_shader=vertex_shader,
             geometry_shader=geometry_shader,
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index a7a3dd25..18e009d3 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -3,7 +3,7 @@
 import uuid
 from collections.abc import Sequence
 from dataclasses import replace
-from typing import Any, Callable, NamedTuple, Protocol
+from typing import Any, Callable, Generic, Protocol, TypeVar
 
 import chex
 import jax
@@ -26,6 +26,14 @@ def normalize(x: jax.Array, axis: Axis | None = None) -> tuple[jax.Array, jax.Ar
     return n, norm
 
 
+T = TypeVar("T")
+
+
+def empty(cls: type[T]) -> Callable[[], T]:
+    all_fields = {f.name: jnp.empty(0) for f in dataclasses.fields(cls)}  # type: ignore
+    return lambda: cls(**all_fields)
+
+
 class PyTreeOps:
     def __add__(self, o: Any) -> Self:
         if o.__class__ is self.__class__:
@@ -200,6 +208,15 @@ class State(PyTreeOps):
     f: Force
     is_active: jax.Array
 
+    @staticmethod
+    def empty() -> Self:
+        return State(
+            p=Position.zeros(0),
+            v=Velocity.zeros(0),
+            f=Force.zeros(0),
+            is_active=jnp.empty(0),
+        )
+
     @staticmethod
     def from_position(p: Position) -> Self:
         n = p.batch_size()
@@ -446,20 +463,20 @@ def _segment_to_circle_impl(
 
 @chex.dataclass
 class StateDict:
-    circle: State | None = None
-    static_circle: State | None = None
-    segment: State | None = None
-    capsule: State | None = None
-    static_capsule: State | None = None
+    circle: State = dataclasses.field(default_factory=State.empty)
+    static_circle: State = dataclasses.field(default_factory=State.empty)
+    segment: State = dataclasses.field(default_factory=State.empty)
+    capsule: State = dataclasses.field(default_factory=State.empty)
+    static_capsule: State = dataclasses.field(default_factory=State.empty)
 
     def concat(self) -> Self:
-        states = [s for s in self.values() if s is not None]  # type: ignore
+        states = [s for s in self.values() if s.batch_size() > 0]  # type: ignore
         return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *states)
 
-    def _get(self, name: str, statec: State) -> State | None:
-        state: State | None = self[name]  # type: ignore
-        if state is None:
-            return None
+    def _get(self, name: str, statec: State) -> State:
+        state = self[name]  # type: ignore
+        if state.batch_size() == 0:
+            return state  # empty state
         else:
             start = _offset(self, name)
             end = start + state.p.batch_size()
@@ -479,33 +496,34 @@ def update(self, statec: State) -> Self:
             static_capsule=static_capsule,
         )
 
-    @functools.partial(jax.jit, static_argnums=(1,))
     def nested_replace(self, query: str, value: Any) -> Self:
         """Convenient method for nested replace"""
         queries = query.split(".")
         objects = [self]
         for q in queries[:-1]:
             objects.append(objects[-1][q])  # type: ignore
-        obj = objects[-1].replace(**{queries[-1]: value})  # type: ignore
+        obj = replace(objects[-1], **{queries[-1]: value})
         for o, q in zip(objects[-2::-1], queries[-2::-1]):
-            obj = o.replace(**{q: obj})  # type: ignore
+            obj = replace(o, **{q: obj})
         return obj
 
 
 @chex.dataclass
 class ShapeDict:
-    circle: Circle | None = None
-    static_circle: Circle | None = None
-    capsule: Capsule | None = None
-    static_capsule: Capsule | None = None
-    segment: Segment | None = None
+    circle: Circle = dataclasses.field(default_factory=empty(Circle))
+    static_circle: Circle = dataclasses.field(default_factory=empty(Circle))
+    capsule: Capsule = dataclasses.field(default_factory=empty(Capsule))
+    static_capsule: Capsule = dataclasses.field(default_factory=empty(Capsule))
+    segment: Segment = dataclasses.field(default_factory=empty(Segment))
 
     def concat(self) -> Shape:
-        shapes = [s.to_shape() for s in self.values() if s is not None]
+        shapes = [
+            s.to_shape() for s in self.values() if s.batch_size() > 0  # type: ignore
+        ]
         return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *shapes)
 
     def n_shapes(self) -> int:
-        return sum([s.batch_size() for s in self.values() if s is not None])
+        return sum([s.batch_size() for s in self.values()])  # type: ignore
 
     def zeros_state(self) -> StateDict:
         circle = then(self.circle, lambda s: State.zeros(len(s.mass)))
@@ -527,16 +545,20 @@ def _offset(sd: ShapeDict | StateDict, name: str) -> int:
     for key in _ALL_SHAPES:
         if key == name:
             return total
-        s = sd[key]
+        s = sd[key]  # type: ignore
         if s is not None:
             total += s.batch_size()
     raise RuntimeError("Unreachable")
 
 
+S1 = TypeVar("S1", bound=Shape)
+S2 = TypeVar("S2", bound=Shape)
+
+
 @chex.dataclass
-class ContactIndices:
-    shape1: Shape
-    shape2: Shape
+class ContactIndices(Generic[S1, S2]):
+    shape1: S1
+    shape2: S2
     index1: jax.Array
     index2: jax.Array
 
@@ -572,7 +594,7 @@ def pair_inner(x: jax.Array, reps: int) -> jax.Array:
     )
 
 
-def _circle_to_circle(ci: ContactIndices, stated: StateDict) -> Contact:
+def _circle_to_circle(ci: ContactIndices[Circle, Circle], stated: StateDict) -> Contact:
     pos1 = jax.tree_map(lambda arr: arr[ci.index1], stated.circle.p)
     pos2 = jax.tree_map(lambda arr: arr[ci.index2], stated.circle.p)
     is_active1 = stated.circle.is_active[ci.index1]
@@ -586,7 +608,10 @@ def _circle_to_circle(ci: ContactIndices, stated: StateDict) -> Contact:
     )
 
 
-def _circle_to_static_circle(ci: ContactIndices, stated: StateDict) -> Contact:
+def _circle_to_static_circle(
+    ci: ContactIndices[Circle, Circle],
+    stated: StateDict,
+) -> Contact:
     pos1 = jax.tree_map(lambda arr: arr[ci.index1], stated.circle.p)
     pos2 = jax.tree_map(lambda arr: arr[ci.index2], stated.static_circle.p)
     is_active1 = stated.circle.is_active[ci.index1]
@@ -600,12 +625,15 @@ def _circle_to_static_circle(ci: ContactIndices, stated: StateDict) -> Contact:
     )
 
 
-def _capsule_to_circle(ci: ContactIndices, stated: StateDict) -> Contact:
+def _capsule_to_circle(
+    ci: ContactIndices[Capsule, Circle],
+    stated: StateDict,
+) -> Contact:
     pos1 = jax.tree_map(lambda arr: arr[ci.index1], stated.capsule.p)
     pos2 = jax.tree_map(lambda arr: arr[ci.index2], stated.circle.p)
     is_active1 = stated.capsule.is_active[ci.index1]
     is_active2 = stated.circle.is_active[ci.index2]
-    return _circle_to_circle_impl(
+    return _capsule_to_circle_impl(
         ci.shape1,
         ci.shape2,
         pos1,
@@ -614,7 +642,10 @@ def _capsule_to_circle(ci: ContactIndices, stated: StateDict) -> Contact:
     )
 
 
-def _segment_to_circle(ci: ContactIndices, stated: StateDict) -> Contact:
+def _segment_to_circle(
+    ci: ContactIndices[Segment, Circle],
+    stated: StateDict,
+) -> Contact:
     pos1 = jax.tree_map(lambda arr: arr[ci.index1], stated.segment.p)
     pos2 = jax.tree_map(lambda arr: arr[ci.index2], stated.circle.p)
     is_active1 = stated.segment.is_active[ci.index1]
@@ -662,24 +693,25 @@ class Space:
         default_factory=dict,
         init=False,
     )
-    _ci_total: ContactIndices | None = dataclasses.field(default=None, init=False)
+    _ci_total: ContactIndices = dataclasses.field(init=False)
     _hash_key: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4, init=False)
 
     def __hash__(self) -> int:
         return hash(self._hash_key)
 
-    def __eq__(self, other: Any) -> int:
+    def __eq__(self, other: Any) -> bool:
         return self._hash_key == other._hash_key
 
     def __post_init__(self) -> None:
         ci_slided_list = []
         offset = 0
         for n1, n2 in _CONTACT_FUNCTIONS.keys():
-            if self.shaped[n1] is not None and self.shaped[n2] is not None:
+            shape1, shape2 = self.shaped[n1], self.shaped[n2]  # type: ignore
+            if shape1.batch_size() > 0 and shape2.batch_size() > 0:
                 if n1 == n2:
-                    ci = _self_ci(self.shaped[n1])
+                    ci = _self_ci(shape1)  # Type
                 else:
-                    ci = _pair_ci(self.shaped[n1], self.shaped[n2])
+                    ci = _pair_ci(shape1, shape2)
                 self._ci[n1, n2] = ci
                 offset_start = offset
                 offset += ci.shape1.batch_size()
@@ -710,19 +742,20 @@ def check_contacts(self, stated: StateDict) -> Contact:
     def n_possible_contacts(self) -> int:
         n = 0
         for n1, n2 in _CONTACT_FUNCTIONS.keys():
-            if self.shaped[n1] is not None and self.shaped[n2] is not None:
-                len1, len2 = len(self.shaped[n1].mass), len(self.shaped[n2].mass)
-                if n1 == n2:
-                    n += len1 * (len1 - 1) // 2
-                else:
-                    n += len1 * len2
+            shape1, shape2 = self.shaped[n1], self.shaped[n2]  # type: ignore
+            len1, len2 = shape1.batch_size(), shape2.batch_size()
+            if n1 == n2:
+                n += len1 * (len1 - 1) // 2
+            else:
+                n += len1 * len2
         return n
 
     def get_contact_mat(self, n1: str, n2: str, contact: jax.Array) -> jax.Array:
         contact_offset = self._contact_offset.get((n1, n2), None)
         assert contact_offset is not None
         from_, to = contact_offset
-        size1, size2 = self.shaped[n1].batch_size(), self.shaped[n2].batch_size()
+        size1 = self.shaped[n1].batch_size()  # type: ignore
+        size2 = self.shaped[n2].batch_size()  # type: ignore
         cnt = contact[from_:to]
         if n1 == n2:
             ret = jnp.zeros((size1, size1), dtype=bool)
@@ -766,14 +799,14 @@ def update_velocity(space: Space, shape: Shape, state: State) -> State:
     # Damping: dv/dt + vc = 0 -> v(t) = v0 * exp(-tc)
     # v(t + dt) = v0 * exp(-tc - dtc) = v0 * exp(-tc) * exp(-dtc) = v(t)exp(-dtc)
     # Thus, linear/angular damping factors are actually exp(-dtc)
-    return state.replace(v=Velocity(angle=v_ang, xy=v_xy), f=state.f.zeros_like())
+    return replace(state, v=Velocity(angle=v_ang, xy=v_xy), f=state.f.zeros_like())
 
 
 def update_position(space: Space, state: State) -> State:
     v_dt = state.v * space.dt
     xy = state.p.xy + v_dt.xy
     angle = (state.p.angle + v_dt.angle + TWO_PI) % TWO_PI
-    return state.replace(p=Position(angle=angle, xy=xy))
+    return replace(state, p=Position(angle=angle, xy=xy))
 
 
 def init_contact_helper(
@@ -838,7 +871,7 @@ def apply_initial_impulse(
         angle=helper.inv_moment2 * jnp.cross(helper.r2, p),
         xy=p * helper.inv_mass2,
     )
-    return solver.replace(v1=v1, v2=v2)
+    return replace(solver, v1=v1, v2=v2)
 
 
 def _rv_a2b(a: jax.Array, ra: jax.Array, b: jax.Array, rb: jax.Array):
@@ -977,7 +1010,7 @@ def correct_position(
     # Filter p1/p2
     dp1 = jnp.where(solver.contact, dp1, 0.0)
     dp2 = jnp.where(solver.contact, dp2, 0.0)
-    return solver.replace(p1=dp1, p2=dp2, min_separation=min_sep)
+    return replace(solver, p1=dp1, p2=dp2, min_separation=min_sep)
 
 
 def solve_constraints(
@@ -1006,31 +1039,31 @@ def gather(a: jax.Array, b: jax.Array, orig: jax.Array) -> jax.Array:
         v2,
     )
     # Warm up the velocity solver
-    solver = solver.replace(v1=v1.into_axy(), v2=v2.into_axy())
+    solver = replace(solver, v1=v1.into_axy(), v2=v2.into_axy())
     solver = apply_initial_impulse(contact, helper, solver)
 
     def vstep(
-        _n_iter: int,
-        vs: tuple[Velocity, VelocitySolver],
-    ) -> tuple[Velocity, VelocitySolver]:
+        _: int,
+        vs: tuple[jax.Array, VelocitySolver],
+    ) -> tuple[jax.Array, VelocitySolver]:
         v_i, solver_i = vs
         solver_i1 = apply_velocity_normal(contact, helper, solver_i)
         v_i1 = gather(solver_i1.v1, solver_i1.v2, v_i)
-        return v_i1, solver_i1.replace(v1=v_i1[idx1], v2=v_i1[idx2])
+        return v_i1, replace(solver_i1, v1=v_i1[idx1], v2=v_i1[idx2])
 
-    v, solver = jax.lax.fori_loop(
+    v_axy, solver = jax.lax.fori_loop(
         0,
         space.n_velocity_iter,
         vstep,
         (v.into_axy(), solver),
     )
     bv1, bv2 = apply_bounce(contact, helper, solver)
-    v = gather(bv1, bv2, v)
+    v_axy = gather(bv1, bv2, v_axy)
 
     def pstep(
-        _n_iter: int,
-        ps: tuple[Position, PositionSolver],
-    ) -> tuple[Position, PositionSolver]:
+        _: int,
+        ps: tuple[jax.Array, PositionSolver],
+    ) -> tuple[jax.Array, PositionSolver]:
         p_i, solver_i = ps
         solver_i1 = correct_position(
             space.bias_factor,
@@ -1041,7 +1074,7 @@ def pstep(
             solver_i,
         )
         p_i1 = gather(solver_i1.p1, solver_i1.p2, p_i)
-        return p_i1, solver_i1.replace(p1=p_i1[idx1], p2=p_i1[idx2])
+        return p_i1, replace(solver_i1, p1=p_i1[idx1], p2=p_i1[idx2])
 
     pos_solver = PositionSolver(
         p1=p1.into_axy(),
@@ -1049,13 +1082,13 @@ def pstep(
         contact=solver.contact,
         min_separation=jnp.zeros_like(p1.angle),
     )
-    p, pos_solver = jax.lax.fori_loop(
+    p_axy, pos_solver = jax.lax.fori_loop(
         0,
         space.n_position_iter,
         pstep,
         (p.into_axy(), pos_solver),
     )
-    return Velocity.from_axy(v), Position.from_axy(p), solver
+    return Velocity.from_axy(v_axy), Position.from_axy(p_axy), solver
 
 
 def step(
@@ -1072,7 +1105,7 @@ def step(
         state.v,
         contact,
     )
-    state = update_position(space, state.replace(v=v, p=p))
+    state = update_position(space, replace(state, v=v, p=p))
     return stated.update(state), solver, contact
 
 
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 47e46a17..5f640d51 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -1,10 +1,11 @@
 import dataclasses
 import warnings
-from typing import Any, NamedTuple
+from typing import Any, Callable, NamedTuple
 
 import jax
 import jax.numpy as jnp
 import numpy as np
+from jax._src.numpy.lax_numpy import TypeVar
 
 from emevo.environments.phyjax2d import (
     Capsule,
@@ -15,6 +16,7 @@
     Space,
     StateDict,
     _vmap_dot,
+    empty,
 )
 from emevo.vec2d import Vec2d, Vec2dLike
 
@@ -40,8 +42,8 @@ def black() -> Self:
 
 
 def _mass_and_moment(
-    mass: float = 1.0,
-    moment: float = 1.0,
+    mass: jax.Array,
+    moment: jax.Array,
     is_static: bool = False,
 ) -> tuple[jax.Array, jax.Array]:
     if is_static:
@@ -70,6 +72,16 @@ def _capsule_mass(
     return jnp.array([mass]), jnp.array([moment])
 
 
+S = TypeVar("S", bound=Shape)
+
+
+def _concat_or(sl: list[S], default_fn: Callable[[], S]) -> S:
+    if len(sl) > 0:
+        return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *sl)
+    else:
+        return default_fn()
+
+
 def _check_params_positive(friction: float, **kwargs) -> None:
     if friction > 1.0:
         warnings.warn(
@@ -186,7 +198,7 @@ def add_segment(
             friction=friction,
             elasticity=elasticity,
         )
-        mass, moment = _mass_and_moment(is_static=True)
+        mass, moment = jnp.array([jnp.inf]), jnp.array([jnp.inf])
         point1 = jnp.array(p1).reshape(1, 2)
         point2 = jnp.array(p2).reshape(1, 2)
         segment = Segment(
@@ -216,7 +228,7 @@ def add_chain_segments(
             friction=friction,
             elasticity=elasticity,
         )
-        mass, moment = _mass_and_moment(is_static=True)
+        mass, moment = jnp.array([jnp.inf]), jnp.array([jnp.inf])
         n_points = len(chain_points)
         for i in range(n_points):
             g1 = chain_points[i - 1][0]
@@ -238,18 +250,12 @@ def add_chain_segments(
             self.segments.append(segment)
 
     def build(self) -> Space:
-        def concat_or(sl: list[Shape]) -> Shape | None:
-            if len(sl) > 0:
-                return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *sl)
-            else:
-                return None
-
         shaped = ShapeDict(
-            circle=concat_or(self.circles),
-            static_circle=concat_or(self.static_circles),
-            segment=concat_or(self.segments),
-            capsule=concat_or(self.capsules),
-            static_capsule=concat_or(self.static_capsules),
+            circle=_concat_or(self.circles, empty(Circle)),
+            static_circle=_concat_or(self.static_circles, empty(Circle)),
+            segment=_concat_or(self.segments, empty(Segment)),
+            capsule=_concat_or(self.capsules, empty(Capsule)),
+            static_capsule=_concat_or(self.static_capsules, empty(Capsule)),
         )
         dt = self.dt
         linear_damping = jnp.exp(-dt * self.linear_damping).item()
@@ -326,7 +332,7 @@ def circle_overlap(
     shaped: ShapeDict,
     stated: StateDict,
     xy: jax.Array,
-    radius: jax.Array,
+    radius: jax.Array | float,
 ) -> jax.Array:
     # Circle overlap
     if stated.circle is not None and shaped.circle is not None:
diff --git a/src/emevo/rl/ppo_normal.py b/src/emevo/rl/ppo_normal.py
index cabcec82..efe4d555 100644
--- a/src/emevo/rl/ppo_normal.py
+++ b/src/emevo/rl/ppo_normal.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import NamedTuple
+from typing import cast, NamedTuple
 
 import chex
 import distrax
@@ -26,10 +26,10 @@ def policy(self) -> distrax.Distribution:
 
 
 class NormalPPONet(eqx.Module):
-    torso: list[eqx.Module]
+    torso: list
     value_head: eqx.nn.Linear
     mean_head: eqx.nn.Linear
-    logstd_param: eqx.nn.Linear
+    logstd_param: jax.Array
 
     def __init__(
         self,
@@ -83,7 +83,7 @@ class Rollout:
     logstds: jax.Array
 
 
-@chex.dataclass(frozen=True, mappable_dataclass=False)
+@chex.dataclass
 class Batch:
     """Batch for PPO, indexable to get a minibatch."""
 
@@ -150,7 +150,7 @@ def make_batch(
         rewards=rollout.rewards.ravel(),
         advantages=advantages.ravel(),
         value_targets=value_targets.ravel(),
-        log_action_probs=log_action_probs,
+        log_action_probs=cast(jax.Array, log_action_probs),
     )
 
 
@@ -228,8 +228,8 @@ def update_once(
             entropy_weight,
         )
         updates, new_opt_state = optax_update(grad, opt_state)
-        dynamic_net = optax.apply_updates(dynamic_net, updates)
-        return (new_opt_state, dynamic_net), None
+        dynamic_net = optax.apply_updates(dynamic_net, updates)  # type: ignore
+        return (new_opt_state, cast(NormalPPONet, dynamic_net)), None
 
     # Prepare minibatches
     minibatches = get_minibatches(batch, key, minibatch_size, n_epochs)
@@ -246,7 +246,7 @@ def update_once(
 
 
 @eqx.filter_vmap(in_axes=(eqx.if_array(0), 0))
-def vmap_apply(net: NormalPPONet, obs: jax.Array) -> jax.Array:
+def vmap_apply(net: NormalPPONet, obs: jax.Array) -> Output:
     return net(obs)
 
 
diff --git a/src/emevo/spaces.py b/src/emevo/spaces.py
index 0fe37e7c..c85af357 100644
--- a/src/emevo/spaces.py
+++ b/src/emevo/spaces.py
@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 import abc
-from collections.abc import Iterable, Sequence
+from collections.abc import Iterable, Iterator, Sequence
 from typing import Any, Generic, NamedTuple, TypeVar
 
 import chex
@@ -12,19 +12,19 @@
 from emevo.types import DTypeLike
 
 INSTANCE = TypeVar("INSTANCE")
+DTYPE = TypeVar("DTYPE")
 
 
-
-class Space(abc.ABC, Generic[INSTANCE]):
-    dtype: jnp.dtype | tuple[jnp.dtype, ...]
+class Space(abc.ABC, Generic[INSTANCE, DTYPE]):
+    dtype: DTYPE
     shape: tuple[int, ...]
 
     @abc.abstractmethod
-    def clip(self, x: jax.Array) -> jax.Array:
+    def clip(self, x: INSTANCE) -> INSTANCE:
         raise NotImplementedError()
 
     @abc.abstractmethod
-    def contains(self, x: INSTANCE) -> bool:
+    def contains(self, x: INSTANCE) -> jax.Array:
         pass
 
     @abc.abstractmethod
@@ -42,7 +42,7 @@ def _short_repr(arr: jax.Array) -> str:
     return str(arr)
 
 
-class BoxSpace(Space[jax.Array]):
+class BoxSpace(Space[jax.Array, jnp.dtype]):
     """gym.spaces.Box, but without RNG"""
 
     def __init__(
@@ -104,10 +104,10 @@ def is_bounded(self, manner: str = "both") -> bool:
     def clip(self, x: jax.Array) -> jax.Array:
         return jnp.clip(x, a_min=self.low, a_max=self.high)
 
-    def contains(self, x: jax.Array) -> bool:
+    def contains(self, x: jax.Array) -> jax.Array:
         type_ok = jnp.can_cast(x.dtype, self.dtype) and x.shape == self.shape
         value_ok = jnp.logical_and(jnp.all(x >= self.low), jnp.all(x <= self.high))
-        return type_ok and value_ok.item()
+        return jnp.logical_and(type_ok, value_ok)
 
     def flatten(self) -> BoxSpace:
         return BoxSpace(low=self.low.flatten(), high=self.high.flatten())
@@ -151,15 +151,6 @@ def sigmoid_scale(self, array: jax.Array) -> jax.Array:
     def __repr__(self) -> str:
         return f"Box({self.low_repr}, {self.high_repr}, {self.shape}, {self.dtype})"
 
-    def __eq__(self, other) -> bool:
-        """Check whether `other` is equivalent to this instance."""
-        return (
-            isinstance(other, self.__class__)
-            and (self.shape == other.shape)
-            and jnp.allclose(self.low, other.low)
-            and jnp.allclose(self.high, other.high)
-        )
-
 
 def get_inf(dtype, sign: str) -> int | float:
     """Returns an infinite that doesn't break things.
@@ -204,7 +195,7 @@ def _broadcast(
     return value
 
 
-class DiscreteSpace(Space[int]):
+class DiscreteSpace(Space[jax.Array, jnp.dtype]):
     """gym.spaces.Discrete, but without RNG"""
 
     def __init__(self, n: int, start: int = 0) -> None:
@@ -215,18 +206,17 @@ def __init__(self, n: int, start: int = 0) -> None:
         self.n = n
         self.start = start
 
-    def clip(self, x: int) -> int:
-        return min(max(0, x), self.n - 1)
+    def clip(self, x: jax.Array) -> jax.Array:
+        return jnp.clip(x, a_min=self.start, a_max=self.start + self.n)
 
-    def contains(self, x: int) -> bool:
+    def contains(self, x: jax.Array) -> jax.Array:
         """Return boolean specifying if x is a valid member of this space."""
-        as_int = x
-        return self.start <= as_int < self.start + self.n
+        return jnp.logical_and(self.start <= x, x < self.start + self.n)
 
     def flatten(self) -> BoxSpace:
         return BoxSpace(low=jnp.zeros(self.n), high=jnp.ones(self.n))
 
-    def sample(self, key: chex.PRNGKey) -> int:
+    def sample(self, key: chex.PRNGKey) -> jax.Array:
         rn = jax.random.randint(key, shape=self.shape, minval=0, maxval=self.n)
         return rn.item() + self.start
 
@@ -245,7 +235,7 @@ def __eq__(self, other) -> bool:
         )
 
 
-class NamedTupleSpace(Space[NamedTuple], Iterable):
+class NamedTupleSpace(Space[NamedTuple, tuple[jnp.dtype, ...]], Iterable):
     """Space that returns namedtuple of other spaces"""
 
     def __init__(self, cls: type[tuple], **spaces_kwargs: Space) -> None:
@@ -274,13 +264,10 @@ def clip(self, x: tuple) -> Any:
         clipped = [space.clip(value) for value, space in zip(x, self.spaces)]
         return self._cls(*clipped)
 
-    def contains(self, x: tuple) -> bool:
+    def contains(self, x: NamedTuple) -> jax.Array:
         """Return boolean specifying if x is a valid member of this space."""
-        for instance, space in zip(x, self.spaces):
-            if not space.contains(instance):
-                return False
-
-        return True
+        contains = [space.contains(instance) for instance, space in zip(x, self.spaces)]
+        return jnp.all(jnp.array(contains))
 
     def flatten(self) -> BoxSpace:
         spaces = [space.flatten() for space in self.spaces]
@@ -288,7 +275,7 @@ def flatten(self) -> BoxSpace:
         high = jnp.concatenate([space.high for space in spaces])
         return BoxSpace(low=low, high=high)
 
-    def sample(self, key: chex.PRNGKey) -> int:
+    def sample(self, key: chex.PRNGKey) -> Any:
         keys = jax.random.split(key, len(self.spaces))
         samples = [space.sample(key) for space, key in zip(self.spaces, keys)]
         return self._cls(*samples)
@@ -297,7 +284,7 @@ def __getitem__(self, key: str) -> Space:
         """Get the space that is associated to `key`."""
         return getattr(self.spaces, key)
 
-    def __iter__(self) -> Iterable[Space]:
+    def __iter__(self) -> Iterator[Space]:
         """Iterator through the keys of the subspaces."""
         yield from self.spaces
 
diff --git a/src/emevo/status.py b/src/emevo/status.py
index d397d0c3..db1b4af5 100644
--- a/src/emevo/status.py
+++ b/src/emevo/status.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import replace
 from typing import Any
 
 import chex
@@ -21,7 +22,7 @@ class Status:
 
     def step(self) -> Self:
         """Get older."""
-        return self.replace(age=self.age + 1)
+        return replace(self, age=self.age + 1)
 
     def update(self, *, energy_delta: jax.Array) -> Self:
         """Update energy."""
@@ -30,7 +31,7 @@ def update(self, *, energy_delta: jax.Array) -> Self:
             energy_delta,
             jnp.zeros_like(energy_delta),
         )
-        return self.replace(energy=jnp.clip(energy, a_min=0.0, a_max=self.capacity))
+        return replace(self, energy=jnp.clip(energy, a_min=0.0, a_max=self.capacity))
 
 
 def init_status(
@@ -50,7 +51,7 @@ def init_status(
         )
     return Status(
         age=jnp.zeros(max_n, dtype=jnp.int32),
-        energy=jnp.ones(max_n, dtype=jnp.float32),
+        energy=jnp.ones(max_n, dtype=jnp.float32) * init_energy,
         is_alive=is_alive,
         capacity=capacity,
         metadata=metadata,
diff --git a/tests/test_observe.py b/tests/test_observe.py
index 1c4762ba..500d8b2a 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -1,12 +1,15 @@
+import typing
+
 import chex
 import jax
 import jax.numpy as jnp
 import pytest
 
-from emevo import Env, TimeStep, make
+from emevo import TimeStep, make
 from emevo.environments.circle_foraging import (
     CFObs,
     CFState,
+    CircleForaging,
     _observe_closest,
     get_sensor_obs,
 )
@@ -21,7 +24,7 @@ def key() -> chex.PRNGKey:
     return jax.random.PRNGKey(43)
 
 
-def reset_env(key: chex.PRNGKey) -> tuple[Env, CFState, TimeStep[CFObs]]:
+def reset_env(key: chex.PRNGKey) -> tuple[CircleForaging, CFState, TimeStep[CFObs]]:
     #     x
     #   O x O
     # O x O  O  (O: agent, x: food)
@@ -50,7 +53,7 @@ def reset_env(key: chex.PRNGKey) -> tuple[Env, CFState, TimeStep[CFObs]]:
         food_radius=FOOD_RADIUS,
     )
     state, timestep = env.reset(key)
-    return env, state, timestep
+    return typing.cast(CircleForaging, env), state, timestep
 
 
 def test_observe_closest(key: chex.PRNGKey) -> None:
@@ -144,7 +147,8 @@ def test_encount_and_collision(key: chex.PRNGKey) -> None:
 
     act2 = jnp.zeros((10, 2)).at[2:5].set(20.0)
     p2p4_ok, p3_ok = False, False
-    for i in range(100):
+    n_iter = 0
+    for _ in range(100):
         p2 = state.physics.circle.p.xy[2]
         p3 = state.physics.circle.p.xy[3]
         p4 = state.physics.circle.p.xy[4]
@@ -163,12 +167,13 @@ def test_encount_and_collision(key: chex.PRNGKey) -> None:
 
         if p2p4_ok and p3_ok:
             break
+        n_iter += 1
 
-    assert i < 99
+    assert n_iter < 99
 
 
 def test_asarray(key: chex.PRNGKey) -> None:
-    env, state, timestep = reset_env(key)
+    env, _, timestep = reset_env(key)
     obs = timestep.obs.as_array()
     obs_shape = env.obs_space.flatten().shape[0]
     chex.assert_shape(obs, (N_MAX_AGENTS, obs_shape))
diff --git a/tests/test_placement.py b/tests/test_placement.py
index c170ff79..b8f12735 100644
--- a/tests/test_placement.py
+++ b/tests/test_placement.py
@@ -5,7 +5,7 @@
 
 from emevo.environments.circle_foraging import _make_physics
 from emevo.environments.env_utils import CircleCoordinate, Locating, place
-from emevo.environments.phyjax2d import Space, StateDict
+from emevo.environments.phyjax2d import Space
 
 N_MAX_AGENTS = 20
 N_MAX_FOODS = 10
@@ -18,9 +18,9 @@ def key() -> chex.PRNGKey:
     return jax.random.PRNGKey(43)
 
 
-def get_space_and_more() -> tuple[Space, StateDict, CircleCoordinate]:
+def get_space_and_coordinate() -> tuple[Space, CircleCoordinate]:
     coordinate = CircleCoordinate((100.0, 100.0), 100.0)
-    space, seg_state = _make_physics(
+    space = _make_physics(
         0.1,
         coordinate,
         linear_damping=0.9,
@@ -32,16 +32,15 @@ def get_space_and_more() -> tuple[Space, StateDict, CircleCoordinate]:
         agent_radius=AGENT_RADIUS,
         food_radius=FOOD_RADIUS,
     )
-    stated = space.shaped.zeros_state().replace(segment=seg_state)
-    return space, stated, coordinate
+    return space, coordinate
 
 
 def test_place_agents(key) -> None:
     n = N_MAX_AGENTS // 2
     keys = jax.random.split(key, n)
-    space, stated, coordinate = get_space_and_more()
+    space, coordinate = get_space_and_coordinate()
     initloc_fn, initloc_state = Locating.UNIFORM(CircleCoordinate((100.0, 100.0), 95.0))
-    assert stated.circle is not None
+    stated = space.shaped.zeros_state()
     for i, key in enumerate(keys):
         xy, ok = place(
             n_trial=10,
@@ -53,6 +52,7 @@ def test_place_agents(key) -> None:
             shaped=space.shaped,
             stated=stated,
         )
+        assert stated.circle is not None
         assert ok, stated.circle.p.xy
         stated = stated.nested_replace("circle.p.xy", stated.circle.p.xy.at[i].set(xy))
 
@@ -72,9 +72,9 @@ def test_place_agents(key) -> None:
 def test_place_foods(key) -> None:
     n = N_MAX_FOODS // 2
     keys = jax.random.split(key, n)
-    space, stated, coordinate = get_space_and_more()
+    space, coordinate = get_space_and_coordinate()
     reprloc_fn, reprloc_state = Locating.UNIFORM(CircleCoordinate((100.0, 100.0), 95.0))
-    assert stated.static_circle is not None
+    stated = space.shaped.zeros_state()
     for i, key in enumerate(keys):
         xy, ok = place(
             n_trial=10,
@@ -86,7 +86,8 @@ def test_place_foods(key) -> None:
             shaped=space.shaped,
             stated=stated,
         )
-        assert ok, stated.circle.p.xy
+        assert stated.static_circle is not None
+        assert ok, stated.static_circle.p.xy
         stated = stated.nested_replace(
             "static_circle.p.xy",
             stated.static_circle.p.xy.at[i].set(xy),

From a459e6ab5e0cd1cb6d47c7fdda568ac1bd2236c6 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 11 Dec 2023 12:08:23 +0900
Subject: [PATCH 103/337] Fix activate

---
 smoke-tests/circle_loop.py                | 21 +++++++++------------
 src/emevo/environments/circle_foraging.py | 13 +++++++++----
 2 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index 211ad9b2..f13fbb51 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -3,6 +3,7 @@
 import datetime
 
 import jax
+import jax.numpy as jnp
 import numpy as np
 import typer
 from tqdm import tqdm
@@ -58,13 +59,14 @@ def main(
     else:
         visualizer = None
 
-    activate_index = n_agents
     jit_step = jax.jit(env.step)
-    # jit_step = env.step
     jit_sample = jax.jit(
         lambda key: jax.vmap(env.act_space.sample)(jax.random.split(key, n_max_agents))
     )
     elapsed_list = []
+
+    replace_interval = steps // 10
+    deactivate_index = n_agents - 1
     for i in tqdm(range(steps)):
         before = datetime.datetime.now()
         state, _ = jit_step(state, jit_sample(keys[i + 1]))
@@ -74,19 +76,14 @@ def main(
         elif i > 10:
             elapsed_list.append(elapsed / datetime.timedelta(microseconds=1))
 
-        if replace and i % 1000 == 0:
-            if n_agents + 5 <= activate_index:
-                state, success = env.deactivate(state, activate_index)
-                if not success:
-                    print(f"Failed to deactivate agent! {activate_index}")
-                else:
-                    activate_index -= 1
+        if replace and i % replace_interval == 0:
+            if i < steps // 2:
+                state = env.deactivate(state, deactivate_index)
+                deactivate_index -= 1
             else:
-                state, success = env.activate(state, 0)
+                state, success = env.activate(state, jnp.array(0))
                 if not success:
                     print("Failed to activate agent!")
-                else:
-                    activate_index += 1
 
         if visualizer is not None:
             visualizer.render(state)
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index f1206072..fda3943d 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -574,8 +574,13 @@ def activate(
     ) -> tuple[CFState, jax.Array]:
         circle = state.physics.circle
         key, place_key = jax.random.split(state.key)
-        new_xy, ok = self._place_agent(key=place_key, stated=state.physics)
-        place = jnp.logical_or(first_true(jnp.logical_not(circle.is_active)), ok)
+        new_xy, ok = self._place_agent(
+            loc_state=state.agent_loc,
+            key=place_key,
+            stated=state.physics,
+        )
+        first_inactive = first_true(jnp.logical_not(circle.is_active))
+        place = jnp.logical_and(first_inactive, ok)
         xy = jnp.where(
             jnp.expand_dims(place, axis=1),
             jnp.expand_dims(new_xy, axis=0),
@@ -598,6 +603,7 @@ def activate(
             state,
             physics=physics,
             profile=profile,
+            agent_loc=state.agent_loc.increment(jnp.sum(place)),
             n_born_agents=state.n_born_agents + jnp.sum(place),
             key=key,
         )
@@ -617,13 +623,12 @@ def deactivate(self, state: CFState, index: Index) -> CFState:
 
     def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
         physics, agent_loc, food_loc = self._initialize_physics_state(key)
-        state = CFState(  # type: ignore
+        state = CFState(
             physics=physics,
             solver=self._physics.init_solver(),
             agent_loc=agent_loc,
             food_loc=food_loc,
             food_num=self._initial_foodnum_state,
-            # Protocols
             key=key,
             step=jnp.array(0, dtype=jnp.int32),
             profile=init_profile(self._n_initial_agents, self._n_max_agents),

From 139c3d2d716d8c0fefc7991958a39efdfa042914 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 11 Dec 2023 15:21:45 +0900
Subject: [PATCH 104/337] Status is now part of Obs

---
 experiments/cf_asexual_evo.py             |  7 +++--
 smoke-tests/circle_loop.py                |  2 +-
 src/emevo/env.py                          | 37 +++++++++++------------
 src/emevo/environments/circle_foraging.py | 32 +++++++++++++++-----
 src/emevo/status.py                       | 28 +++++++----------
 5 files changed, 57 insertions(+), 49 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 129705b7..3da11d07 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -70,7 +70,8 @@ def exec_rollout(
     state: State,
     initial_obs: Obs,
     env: Env,
-    network: NormalPPONet,
+    network: NormalPPONet
+    reward_fn: RewardFn,
     prng_key: jax.Array,
     n_rollout_steps: int,
 ) -> tuple[State, Rollout, Obs, jax.Array]:
@@ -78,12 +79,12 @@ def step_rollout(
         carried: tuple[State, Obs, Profile],
         key: jax.Array,
     ) -> tuple[tuple[State, Obs, Profile], Rollout]:
-        state_t, obs_t = carried
+        state_t, obs_t, profile = carried
         obs_t_array = obs_t.as_array()
         net_out = vmap_apply(network, obs_t_array)
         actions = net_out.policy().sample(seed=key)
         state_t1, timestep = env.step(state_t, env.act_space.sigmoid_scale(actions))
-        rewards = obs_t.collision[:, 1].astype(jnp.float32).reshape(-1, 1)
+        rewards = reward_fn()
         rollout = Rollout(
             observations=obs_t_array,
             actions=actions,
diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index f13fbb51..ba758ca4 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -81,7 +81,7 @@ def main(
                 state = env.deactivate(state, deactivate_index)
                 deactivate_index -= 1
             else:
-                state, success = env.activate(state, jnp.array(0))
+                state, success = env.activate(state, jnp.array(0), jnp.array(10.0))
                 if not success:
                     print("Failed to activate agent!")
 
diff --git a/src/emevo/env.py b/src/emevo/env.py
index 706cb12f..fe3ea98e 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -11,6 +11,7 @@
 from jax.typing import ArrayLike
 
 from emevo.spaces import Space
+from emevo.status import Status
 from emevo.types import Index
 from emevo.visualizer import Visualizer
 
@@ -32,23 +33,17 @@ def activate(
         uid: jax.Array,
         step: jax.Array,
     ) -> Self:
-        unique_id = self.unique_id.at[index].set(uid)
-        birthtime = self.birthtime.at[index].set(step)
-        generation = self.generation.at[index].set(parent_gen + 1)
         return Profile(
-            birthtime=birthtime,
-            generation=generation,
-            unique_id=unique_id,
+            birthtime=self.birthtime.at[index].set(step),
+            generation=self.generation.at[index].set(parent_gen + 1),
+            unique_id=self.unique_id.at[index].set(uid),
         )
 
     def deactivate(self, index: Index) -> Self:
-        unique_id = self.unique_id.at[index].set(-1)
-        birthtime = self.birthtime.at[index].set(-1)
-        generation = self.generation.at[index].set(-1)
         return Profile(
-            birthtime=birthtime,
-            generation=generation,
-            unique_id=unique_id,
+            birthtime=self.birthtime.at[index].set(-1),
+            generation=self.generation.at[index].set(-1),
+            unique_id=self.unique_id.at[index].set(-1),
         )
 
     def is_active(self) -> jax.Array:
@@ -57,13 +52,10 @@ def is_active(self) -> jax.Array:
 
 def init_profile(n: int, max_n: int) -> Profile:
     minus_1 = jnp.ones(max_n - n, dtype=jnp.int32) * -1
-    birthtime = jnp.concatenate((jnp.zeros(n, dtype=jnp.int32), minus_1))
-    generation = jnp.concatenate((jnp.zeros(n, dtype=jnp.int32), minus_1))
-    unique_id = jnp.concatenate((jnp.arange(n, dtype=jnp.int32), minus_1))
     return Profile(
-        birthtime=birthtime,
-        generation=generation,
-        unique_id=unique_id,
+        birthtime=jnp.concatenate((jnp.zeros(n, dtype=jnp.int32), minus_1)),
+        generation=jnp.concatenate((jnp.zeros(n, dtype=jnp.int32), minus_1)),
+        unique_id=jnp.concatenate((jnp.arange(n, dtype=jnp.int32), minus_1)),
     )
 
 
@@ -71,6 +63,7 @@ class StateProtocol(Protocol):
     key: chex.PRNGKey
     step: jax.Array
     profile: Profile
+    status: Status
     n_born_agents: jax.Array
 
     def is_extinct(self) -> bool:
@@ -94,7 +87,6 @@ def as_array(self) -> jax.Array:
 class TimeStep(Generic[OBS]):
     encount: jax.Array | None
     obs: OBS
-    energy_delta: jax.Array
     info: dict[str, Any] = dataclasses.field(default_factory=dict)
 
 
@@ -122,7 +114,12 @@ def step(self, state: STATE, action: ArrayLike) -> tuple[STATE, TimeStep[OBS]]:
         pass
 
     @abc.abstractmethod
-    def activate(self, state: STATE, parent_gen: jax.Array) -> tuple[STATE, jax.Array]:
+    def activate(
+        self,
+        state: STATE,
+        parent_gen: jax.Array,
+        init_energy: jax.Array,
+    ) -> tuple[STATE, jax.Array]:
         """
         Mark an agent or some agents active.
         This method fails if there isn't enough space, returning (STATE, False).
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index fda3943d..5dc242a4 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -44,6 +44,7 @@
     make_square,
 )
 from emevo.spaces import BoxSpace, NamedTupleSpace
+from emevo.status import Status, init_status
 from emevo.types import Index
 from emevo.vec2d import Vec2d
 
@@ -87,6 +88,7 @@ class CFState:
     key: chex.PRNGKey
     step: jax.Array
     profile: Profile
+    status: Status
     n_born_agents: jax.Array
 
     @property
@@ -311,6 +313,8 @@ def __init__(
         angular_damping: float = 0.6,
         max_force: float = 40.0,
         min_force: float = -20.0,
+        init_energy: float = 20.0,
+        energy_capacity: float = 100.0,
         force_energy_consumption: float = 0.01 / 40.0,
         n_velocity_iter: int = 6,
         n_position_iter: int = 2,
@@ -351,6 +355,8 @@ def __init__(
         self._n_initial_foods = self._food_num_fn.initial
         self._n_max_foods = n_max_foods
         self._max_place_attempts = max_place_attempts
+        self._init_energy = init_energy
+        self._energy_capacity = energy_capacity
         # Physics
         if isinstance(obstacles, str):
             obs_list = Obstacle(obstacles).as_list(self._x_range, self._y_range)
@@ -544,7 +550,7 @@ def step(
         # energy_delta = food - coef * force
         force_sum = jnp.abs(f1_raw) + jnp.abs(f2_raw)
         energy_delta = food_collision - self._force_energy_consumption * force_sum
-        timestep = TimeStep(encount=c2c, obs=obs, energy_delta=energy_delta)
+        timestep = TimeStep(encount=c2c, obs=obs)
         # Remove and reproduce foods
         key, food_key = jax.random.split(state.key)
         stated, food_num, food_loc = self._remove_and_reproduce_foods(
@@ -554,6 +560,7 @@ def step(
             state.food_num,
             state.food_loc,
         )
+        status = state.status.update(energy_delta=energy_delta)
         state = CFState(
             physics=stated,
             solver=solver,
@@ -563,6 +570,7 @@ def step(
             key=key,
             step=state.step + 1,
             profile=state.profile,
+            status=status,
             n_born_agents=state.n_born_agents,
         )
         return state, timestep
@@ -571,6 +579,7 @@ def activate(
         self,
         state: CFState,
         parent_gen: jax.Array,
+        init_energy: jax.Array,
     ) -> tuple[CFState, jax.Array]:
         circle = state.physics.circle
         key, place_key = jax.random.split(state.key)
@@ -599,10 +608,12 @@ def activate(
             state.n_born_agents,
             state.step,
         )
+        status = state.status.activate(place, init_energy=init_energy)
         new_state = replace(
             state,
             physics=physics,
             profile=profile,
+            status=status,
             agent_loc=state.agent_loc.increment(jnp.sum(place)),
             n_born_agents=state.n_born_agents + jnp.sum(place),
             key=key,
@@ -619,10 +630,18 @@ def deactivate(self, state: CFState, index: Index) -> CFState:
         circle = replace(state.physics.circle, p=p, v=v, is_active=is_active)
         physics = replace(state.physics, circle=circle)
         profile = state.profile.deactivate(index)
-        return replace(state, physics=physics, profile=profile)
+        status = state.status.deactivate(index)
+        return replace(state, physics=physics, profile=profile, status=status)
 
     def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
         physics, agent_loc, food_loc = self._initialize_physics_state(key)
+        profile = init_profile(self._n_initial_agents, self._n_max_agents)
+        status = init_status(
+            self._n_initial_agents,
+            self._n_max_agents,
+            self._init_energy,
+            self._energy_capacity,
+        )
         state = CFState(
             physics=physics,
             solver=self._physics.init_solver(),
@@ -631,7 +650,8 @@ def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
             food_num=self._initial_foodnum_state,
             key=key,
             step=jnp.array(0, dtype=jnp.int32),
-            profile=init_profile(self._n_initial_agents, self._n_max_agents),
+            profile=profile,
+            status=status,
             n_born_agents=jnp.array(self._n_initial_agents, dtype=jnp.int32),
         )
         sensor_obs = self._sensor_obs(stated=physics)
@@ -642,11 +662,7 @@ def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
             velocity=physics.circle.v.xy,
             angular_velocity=physics.circle.v.angle,
         )
-        timestep = TimeStep(
-            encount=None,
-            obs=obs,
-            energy_delta=jnp.zeros(self._n_max_agents),
-        )
+        timestep = TimeStep(encount=None, obs=obs)
         return state, timestep
 
     def _initialize_physics_state(
diff --git a/src/emevo/status.py b/src/emevo/status.py
index db1b4af5..ab87fdea 100644
--- a/src/emevo/status.py
+++ b/src/emevo/status.py
@@ -7,6 +7,8 @@
 import jax
 import jax.numpy as jnp
 
+from emevo.types import Index
+
 Self = Any
 
 
@@ -16,43 +18,35 @@ class Status:
 
     age: jax.Array
     energy: jax.Array
-    is_alive: jax.Array
     capacity: float = 100.0
-    metadata: dict[str, Any] | None = None
 
     def step(self) -> Self:
         """Get older."""
         return replace(self, age=self.age + 1)
 
+    def activate(self, index: Index, init_energy: jax.Array) -> Self:
+        age = self.age.at[index].set(0)
+        energy = self.energy.at[index].set(init_energy)
+        return replace(self, age=age, energy=energy)
+
+    def deactivate(self, index: Index) -> Self:
+        return replace(self, age=self.age.at[index].set(-1))
+
     def update(self, *, energy_delta: jax.Array) -> Self:
         """Update energy."""
-        energy = self.energy + jnp.where(
-            self.is_alive,
-            energy_delta,
-            jnp.zeros_like(energy_delta),
-        )
+        energy = self.energy + energy_delta
         return replace(self, energy=jnp.clip(energy, a_min=0.0, a_max=self.capacity))
 
 
 def init_status(
-    *,
     n: int,
     max_n: int,
     init_energy: float,
     capacity: float = 100.0,
-    metadata: dict[str, Any] | None = None,
 ) -> Status:
     assert max_n >= n
-    if max_n == n:
-        is_alive = jnp.ones(n, dtype=bool)
-    else:
-        is_alive = jnp.concatenate(
-            (jnp.ones(n, dtype=bool), jnp.zeros(max_n - n, dtype=bool))
-        )
     return Status(
         age=jnp.zeros(max_n, dtype=jnp.int32),
         energy=jnp.ones(max_n, dtype=jnp.float32) * init_energy,
-        is_alive=is_alive,
         capacity=capacity,
-        metadata=metadata,
     )

From a67ee2ff57d9a7ee027ed2690ca71ba894bebb71 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 11 Dec 2023 17:54:04 +0900
Subject: [PATCH 105/337] Linear Reward

---
 experiments/cf_asexual_evo.py             | 32 ++++++++++++++++++-----
 src/emevo/env.py                          | 24 +++++++++--------
 src/emevo/environments/circle_foraging.py |  6 ++---
 3 files changed, 41 insertions(+), 21 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 3da11d07..aff0faf2 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -11,12 +11,12 @@
 import optax
 import typer
 
-from emevo import Env, Profile, make
+from emevo import Env, make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
+from emevo.rl.ppo_normal import NormalPPONet
+from emevo.rl.ppo_normal import Rollout as OriginalRollout
 from emevo.rl.ppo_normal import (
-    NormalPPONet,
-    Rollout,
     vmap_apply,
     vmap_batch,
     vmap_net,
@@ -28,6 +28,24 @@
 N_MAX_AGENTS: int = 10
 
 
+@chex.dataclass
+class Rollout(OriginalRollout):
+    collision: jax.Array
+
+
+class LinearReward(eqx.Module):
+    weight: jax.Array
+    max_action_norm: float
+
+    def __init__(self, max_action_norm: float, key: chex.PRNGKey) -> None:
+        self.weight = jax.random.normal(key, (1, 4))
+        self.max_action_norm = max_action_norm
+
+    def __call__(self, collision: jax.Array, action: jax.Array) -> jax.Array:
+        action_norm = jnp.sqrt(jnp.sum(action**2, axis=-1, keepdims=True))
+        return jnp.concatenate((collision, action_norm), axis=1) @ self.weight.T
+
+
 def weight_summary(network):
     params, _ = eqx.partition(network, eqx.is_inexact_array)
     params_mean = jax.tree_map(jnp.mean, params)
@@ -70,16 +88,16 @@ def exec_rollout(
     state: State,
     initial_obs: Obs,
     env: Env,
-    network: NormalPPONet
+    network: NormalPPONet,
     reward_fn: RewardFn,
     prng_key: jax.Array,
     n_rollout_steps: int,
 ) -> tuple[State, Rollout, Obs, jax.Array]:
     def step_rollout(
-        carried: tuple[State, Obs, Profile],
+        carried: tuple[State, Obs],
         key: jax.Array,
-    ) -> tuple[tuple[State, Obs, Profile], Rollout]:
-        state_t, obs_t, profile = carried
+    ) -> tuple[tuple[State, Obs], Rollout]:
+        state_t, obs_t = carried
         obs_t_array = obs_t.as_array()
         net_out = vmap_apply(network, obs_t_array)
         actions = net_out.policy().sample(seed=key)
diff --git a/src/emevo/env.py b/src/emevo/env.py
index fe3ea98e..540e98fd 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -59,7 +59,19 @@ def init_profile(n: int, max_n: int) -> Profile:
     )
 
 
+class ObsProtocol(Protocol):
+    """Abstraction for agent's observation"""
+
+    def as_array(self) -> jax.Array:
+        ...
+
+
+OBS = TypeVar("OBS", bound="ObsProtocol")
+
+
 class StateProtocol(Protocol):
+    """Environment's internal state"""
+
     key: chex.PRNGKey
     step: jax.Array
     profile: Profile
@@ -73,20 +85,10 @@ def is_extinct(self) -> bool:
 STATE = TypeVar("STATE", bound="StateProtocol")
 
 
-class ObsProtocol(Protocol):
-    """Each state should have PRNG key"""
-
-    def as_array(self) -> jax.Array:
-        ...
-
-
-OBS = TypeVar("OBS", bound="ObsProtocol")
-
-
 @chex.dataclass
 class TimeStep(Generic[OBS]):
-    encount: jax.Array | None
     obs: OBS
+    encount: jax.Array
     info: dict[str, Any] = dataclasses.field(default_factory=dict)
 
 
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 5dc242a4..a40958c6 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -547,9 +547,9 @@ def step(
             velocity=stated.circle.v.xy,
             angular_velocity=stated.circle.v.angle,
         )
-        # energy_delta = food - coef * force
-        force_sum = jnp.abs(f1_raw) + jnp.abs(f2_raw)
-        energy_delta = food_collision - self._force_energy_consumption * force_sum
+        # energy_delta = food - coef * |force|
+        force_norm = jnp.sqrt(f1_raw**2 + f2_raw**2)
+        energy_delta = food_collision - self._force_energy_consumption * force_norm
         timestep = TimeStep(encount=c2c, obs=obs)
         # Remove and reproduce foods
         key, food_key = jax.random.split(state.key)

From 93ca7799a2acb2308b496da61eb4598e8c776af4 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 12 Dec 2023 12:00:53 +0900
Subject: [PATCH 106/337] Simplify genetic_ops

---
 src/emevo/genetic_ops.py | 48 +++++++++-------------------------------
 1 file changed, 11 insertions(+), 37 deletions(-)

diff --git a/src/emevo/genetic_ops.py b/src/emevo/genetic_ops.py
index 999bedf0..633ed283 100644
--- a/src/emevo/genetic_ops.py
+++ b/src/emevo/genetic_ops.py
@@ -1,4 +1,4 @@
-""" Genetics operations for any pytree."""
+""" Genetics operations for array"""
 
 from __future__ import annotations
 
@@ -13,7 +13,7 @@
 
 class Crossover(abc.ABC):
     @abc.abstractmethod
-    def _select(
+    def __call__(
         self,
         prng_key: chex.PRNGKey,
         array1: jax.Array,
@@ -21,38 +21,12 @@ def _select(
     ) -> jax.Array:
         pass
 
-    def __call__(
-        self,
-        prng_key: chex.PRNGKey,
-        params_a: chex.ArrayTree,
-        params_b: chex.ArrayTree,
-    ) -> chex.ArrayTree:
-        leaves, treedef = jax.tree_util.tree_flatten(params_a)
-        prng_keys = jax.random.split(prng_key, len(leaves))
-        result = jax.tree_map(
-            self._select,
-            treedef.unflatten(prng_keys),
-            params_a,
-            params_b,
-        )
-        return result
-
 
 class Mutation(abc.ABC):
     @abc.abstractmethod
-    def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
+    def __call__(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
         pass
 
-    def __call__(
-        self,
-        prng_key: chex.PRNGKey,
-        params: chex.ArrayTree,
-    ) -> chex.PRNGKey:
-        leaves, treedef = jax.tree_util.tree_flatten(params)
-        prng_keys = jax.random.split(prng_key, len(leaves))
-        result = jax.tree_map(self._add_noise, treedef.unflatten(prng_keys), params)
-        return result
-
 
 @dataclasses.dataclass(frozen=True)
 class UniformCrossover(Crossover):
@@ -61,7 +35,7 @@ class UniformCrossover(Crossover):
     def __post_init__(self) -> None:
         assert self.bias >= 0.0 and self.bias <= 0.5
 
-    def _select(
+    def __call__(
         self,
         prng_key: chex.PRNGKey,
         array1: jax.Array,
@@ -80,15 +54,15 @@ class CrossoverAndMutation(Crossover):
     crossover: Crossover
     mutation: Mutation
 
-    def _select(
+    def __call__(
         self,
         prng_key: chex.PRNGKey,
         array1: jax.Array,
         array2: jax.Array,
     ) -> jax.Array:
         key1, key2 = jax.random.split(prng_key)
-        selected = self.crossover._select(key1, array1, array2)
-        return self.mutation._add_noise(key2, selected)
+        selected = self.crossover(key1, array1, array2)
+        return self.mutation(key2, selected)
 
 
 @dataclasses.dataclass(frozen=True)
@@ -96,9 +70,9 @@ class BernoulliMixtureMutation(Mutation):
     mutation_prob: float
     mutator: Mutation
 
-    def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
+    def __call__(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
         key1, key2 = jax.random.split(prng_key)
-        noise_added = self.mutator._add_noise(key1, array)
+        noise_added = self.mutator(key1, array)
         is_mutated = jax.random.bernoulli(
             key2,
             self.mutation_prob,
@@ -111,7 +85,7 @@ def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
 class GaussianMutation(Mutation):
     std_dev: float
 
-    def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
+    def __call__(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
         std_normal = jax.random.normal(prng_key, shape=array.shape)
         return array + std_normal * self.std_dev
 
@@ -120,7 +94,7 @@ def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
 class UniformMutation(Mutation):
     max_noise: float
 
-    def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
+    def __call__(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
         uniform = jax.random.uniform(
             prng_key,
             shape=array.shape,

From adc7ce00369a28dc211889de1e862a9815736945 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 12 Dec 2023 19:14:29 +0900
Subject: [PATCH 107/337] activate and deactivate take flag instead of index

---
 experiments/cf_asexual_evo.py             |  35 +++----
 smoke-tests/circle_loop.py                |  12 ++-
 src/emevo/__init__.py                     |   4 +-
 src/emevo/env.py                          |  77 ++++++++++----
 src/emevo/environments/circle_foraging.py | 117 +++++++++++++---------
 src/emevo/environments/env_utils.py       |   4 +-
 src/emevo/status.py                       |  52 ----------
 src/emevo/types.py                        |   2 -
 tests/test_status.py                      |   2 +-
 9 files changed, 156 insertions(+), 149 deletions(-)
 delete mode 100644 src/emevo/status.py

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index aff0faf2..3655cd06 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -14,9 +14,9 @@
 from emevo import Env, make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
-from emevo.rl.ppo_normal import NormalPPONet
-from emevo.rl.ppo_normal import Rollout as OriginalRollout
 from emevo.rl.ppo_normal import (
+    NormalPPONet,
+    Rollout,
     vmap_apply,
     vmap_batch,
     vmap_net,
@@ -28,29 +28,23 @@
 N_MAX_AGENTS: int = 10
 
 
-@chex.dataclass
-class Rollout(OriginalRollout):
-    collision: jax.Array
-
-
 class LinearReward(eqx.Module):
     weight: jax.Array
     max_action_norm: float
 
-    def __init__(self, max_action_norm: float, key: chex.PRNGKey) -> None:
-        self.weight = jax.random.normal(key, (1, 4))
+    def __init__(
+        self,
+        max_action_norm: float,
+        n_agents: int,
+        key: chex.PRNGKey,
+    ) -> None:
+        self.weight = jax.random.normal(key, (n_agents, 4))
         self.max_action_norm = max_action_norm
 
     def __call__(self, collision: jax.Array, action: jax.Array) -> jax.Array:
         action_norm = jnp.sqrt(jnp.sum(action**2, axis=-1, keepdims=True))
-        return jnp.concatenate((collision, action_norm), axis=1) @ self.weight.T
-
-
-def weight_summary(network):
-    params, _ = eqx.partition(network, eqx.is_inexact_array)
-    params_mean = jax.tree_map(jnp.mean, params)
-    for k, v in jax.tree_util.tree_leaves_with_path(params_mean):
-        print(k, v)
+        input_ = jnp.concatenate((collision, action_norm), axis=1)
+        return jax.vmap(jnp.dot)(input_, self.weight)
 
 
 def visualize(
@@ -89,7 +83,7 @@ def exec_rollout(
     initial_obs: Obs,
     env: Env,
     network: NormalPPONet,
-    reward_fn: RewardFn,
+    reward_fn: LinearReward,
     prng_key: jax.Array,
     n_rollout_steps: int,
 ) -> tuple[State, Rollout, Obs, jax.Array]:
@@ -97,12 +91,13 @@ def step_rollout(
         carried: tuple[State, Obs],
         key: jax.Array,
     ) -> tuple[tuple[State, Obs], Rollout]:
+        act_key, hazard_key, birth_key = jax.random.split(key, 3)
         state_t, obs_t = carried
         obs_t_array = obs_t.as_array()
         net_out = vmap_apply(network, obs_t_array)
-        actions = net_out.policy().sample(seed=key)
+        actions = net_out.policy().sample(seed=act_key)
         state_t1, timestep = env.step(state_t, env.act_space.sigmoid_scale(actions))
-        rewards = reward_fn()
+        rewards = reward_fn(obs_t.collision, actions)  # type: ignore
         rollout = Rollout(
             observations=obs_t_array,
             actions=actions,
diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index ba758ca4..3f7de156 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -67,6 +67,7 @@ def main(
 
     replace_interval = steps // 10
     deactivate_index = n_agents - 1
+    activate_p = jnp.zeros(n_max_agents).at[jnp.arange(5)].set(0.5)
     for i in tqdm(range(steps)):
         before = datetime.datetime.now()
         state, _ = jit_step(state, jit_sample(keys[i + 1]))
@@ -78,12 +79,15 @@ def main(
 
         if replace and i % replace_interval == 0:
             if i < steps // 2:
-                state = env.deactivate(state, deactivate_index)
+                flag = jnp.zeros(n_max_agents, dtype=bool).at[deactivate_index].set(True)
+                state = env.deactivate(state, flag)
                 deactivate_index -= 1
             else:
-                state, success = env.activate(state, jnp.array(0), jnp.array(10.0))
-                if not success:
-                    print("Failed to activate agent!")
+                flag = jax.random.bernoulli(keys[i + 1], p=activate_p)
+                state, success = env.activate(state, flag)
+                for idx in range(n_max_agents):
+                    if flag[idx] and not success[idx]:
+                        print(f"Failed to activate agent for a parent {idx}")
 
         if visualizer is not None:
             visualizer.render(state)
diff --git a/src/emevo/__init__.py b/src/emevo/__init__.py
index 1065910c..2a9e858f 100644
--- a/src/emevo/__init__.py
+++ b/src/emevo/__init__.py
@@ -4,11 +4,9 @@
 """
 
 
-from emevo.env import Profile, Env, TimeStep
+from emevo.env import Env, Profile, Status, TimeStep
 from emevo.environments import make, register
-from emevo.status import Status
 from emevo.vec2d import Vec2d
 from emevo.visualizer import Visualizer
 
-
 __version__ = "0.1.0"
diff --git a/src/emevo/env.py b/src/emevo/env.py
index 540e98fd..c52e5981 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -3,6 +3,7 @@
 
 import abc
 import dataclasses
+from dataclasses import replace
 from typing import Any, Generic, Protocol, TypeVar
 
 import chex
@@ -11,13 +12,51 @@
 from jax.typing import ArrayLike
 
 from emevo.spaces import Space
-from emevo.status import Status
-from emevo.types import Index
 from emevo.visualizer import Visualizer
 
 Self = Any
 
 
+@chex.dataclass
+class Status:
+    """Default status implementation with age and energy."""
+
+    age: jax.Array
+    energy: jax.Array
+    capacity: float = 100.0
+
+    def step(self) -> Self:
+        """Get older."""
+        return replace(self, age=self.age + 1)
+
+    def activate(self, flag: jax.Array, init_energy: jax.Array) -> Self:
+        age = jnp.where(flag, 0, self.age)
+        energy = jnp.where(flag, init_energy, self.energy)
+        return replace(self, age=age, energy=energy)
+
+    def deactivate(self, flag: jax.Array) -> Self:
+        return replace(self, age=jnp.where(flag, -1, self.age))
+
+    def update(self, *, energy_delta: jax.Array) -> Self:
+        """Update energy."""
+        energy = self.energy + energy_delta
+        return replace(self, energy=jnp.clip(energy, a_min=0.0, a_max=self.capacity))
+
+
+def init_status(
+    n: int,
+    max_n: int,
+    init_energy: float,
+    capacity: float = 100.0,
+) -> Status:
+    assert max_n >= n
+    return Status(
+        age=jnp.zeros(max_n, dtype=jnp.int32),
+        energy=jnp.ones(max_n, dtype=jnp.float32) * init_energy,
+        capacity=capacity,
+    )
+
+
 @chex.dataclass
 class Profile:
     """Agent profile."""
@@ -26,24 +65,25 @@ class Profile:
     generation: jax.Array
     unique_id: jax.Array
 
-    def activate(
-        self,
-        index: Index,
-        parent_gen: jax.Array,
-        uid: jax.Array,
-        step: jax.Array,
-    ) -> Self:
+    def activate(self, flag: jax.Array, step: jax.Array) -> Self:
+        birthtime = jnp.where(flag, step, self.birthtime)
+        generation = jnp.where(flag, self.generation + 1, self.generation)
+        unique_id = jnp.where(
+            flag,
+            jnp.cumsum(flag) + jnp.max(self.unique_id),
+            self.unique_id,
+        )
         return Profile(
-            birthtime=self.birthtime.at[index].set(step),
-            generation=self.generation.at[index].set(parent_gen + 1),
-            unique_id=self.unique_id.at[index].set(uid),
+            birthtime=birthtime,
+            generation=generation,
+            unique_id=unique_id,
         )
 
-    def deactivate(self, index: Index) -> Self:
+    def deactivate(self, flag: jax.Array) -> Self:
         return Profile(
-            birthtime=self.birthtime.at[index].set(-1),
-            generation=self.generation.at[index].set(-1),
-            unique_id=self.unique_id.at[index].set(-1),
+            birthtime=jnp.where(flag, -1, self.birthtime),
+            generation=jnp.where(flag, -1, self.generation),
+            unique_id=jnp.where(flag, -1, self.unique_id),
         )
 
     def is_active(self) -> jax.Array:
@@ -119,8 +159,7 @@ def step(self, state: STATE, action: ArrayLike) -> tuple[STATE, TimeStep[OBS]]:
     def activate(
         self,
         state: STATE,
-        parent_gen: jax.Array,
-        init_energy: jax.Array,
+        is_parent: jax.Array,
     ) -> tuple[STATE, jax.Array]:
         """
         Mark an agent or some agents active.
@@ -129,7 +168,7 @@ def activate(
         pass
 
     @abc.abstractmethod
-    def deactivate(self, state: STATE, index: Index) -> STATE:
+    def deactivate(self, state: STATE, flag: jax.Array) -> STATE:
         """
         Deactivate an agent or some agents. The shape of observations should remain the
         same so that `Env.step` is compiled onle once. So, to represent that an agent is
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index a40958c6..2309f753 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -13,7 +13,15 @@
 import numpy as np
 from jax.typing import ArrayLike
 
-from emevo.env import Env, Profile, TimeStep, Visualizer, init_profile
+from emevo.env import (
+    Env,
+    Profile,
+    Status,
+    TimeStep,
+    Visualizer,
+    init_profile,
+    init_status,
+)
 from emevo.environments.env_utils import (
     CircleCoordinate,
     FoodNumState,
@@ -44,8 +52,6 @@
     make_square,
 )
 from emevo.spaces import BoxSpace, NamedTupleSpace
-from emevo.status import Status, init_status
-from emevo.types import Index
 from emevo.vec2d import Vec2d
 
 MAX_ANGULAR_VELOCITY: float = float(np.pi)
@@ -288,6 +294,10 @@ def body(
     return state, solver, contacts
 
 
+def _first_n_true(boolean_array: jax.Array, n: jax.Array) -> jax.Array:
+    return jnp.logical_and(boolean_array, jnp.cumsum(boolean_array) <= n)
+
+
 class CircleForaging(Env):
     def __init__(
         self,
@@ -302,6 +312,7 @@ def __init__(
         env_radius: float = 120.0,
         env_shape: Literal["square", "circle"] = "square",
         obstacles: list[tuple[Vec2d, Vec2d]] | str = "none",
+        newborn_loc: Literal["neighbor", "uniform"] = "uniform",
         n_agent_sensors: int = 16,
         sensor_length: float = 100.0,
         sensor_range: tuple[float, float] | SensorRange = SensorRange.WIDE,
@@ -316,6 +327,7 @@ def __init__(
         init_energy: float = 20.0,
         energy_capacity: float = 100.0,
         force_energy_consumption: float = 0.01 / 40.0,
+        energy_share_ratio: float = 0.4,
         n_velocity_iter: int = 6,
         n_position_iter: int = 2,
         n_physics_iter: int = 5,
@@ -345,8 +357,11 @@ def __init__(
         self._agent_loc_fn, self._initial_agentloc_state = self._make_agent_loc_fn(
             agent_loc_fn
         )
-        # Energy consumption
+        # Energy
         self._force_energy_consumption = force_energy_consumption
+        self._init_energy = init_energy
+        self._energy_capacity = energy_capacity
+        self._energy_share_ratio = energy_share_ratio
         # Initial numbers
         assert n_max_agents > n_initial_agents
         assert n_max_foods > self._food_num_fn.initial
@@ -355,8 +370,6 @@ def __init__(
         self._n_initial_foods = self._food_num_fn.initial
         self._n_max_foods = n_max_foods
         self._max_place_attempts = max_place_attempts
-        self._init_energy = init_energy
-        self._energy_capacity = energy_capacity
         # Physics
         if isinstance(obstacles, str):
             obs_list = Obstacle(obstacles).as_list(self._x_range, self._y_range)
@@ -397,13 +410,13 @@ def __init__(
         act_p2 = Vec2d(0, agent_radius).rotated(-np.pi * 0.75)
         self._act_p1 = jnp.tile(jnp.array(act_p1), (self._n_max_agents, 1))
         self._act_p2 = jnp.tile(jnp.array(act_p2), (self._n_max_agents, 1))
-        self._place_agent = jax.jit(
+        self._init_agent = jax.jit(
             functools.partial(
                 place,
                 n_trial=self._max_place_attempts,
                 radius=self._agent_radius,
                 coordinate=self._coordinate,
-                loc_fn=self._agent_loc_fn,
+                loc_fn=jax.vmap(self._agent_loc_fn, in_axes=(0, None)),
                 shaped=self._physics.shaped,
             )
         )
@@ -413,10 +426,32 @@ def __init__(
                 n_trial=self._max_place_attempts,
                 radius=self._food_radius,
                 coordinate=self._coordinate,
-                loc_fn=self._food_loc_fn,
+                loc_fn=jax.vmap(self._food_loc_fn, in_axes=(0, None)),
                 shaped=self._physics.shaped,
             )
         )
+        if newborn_loc == "uniform":
+
+            def place_newborn(
+                state: LocatingState,
+                stated: StateDict,
+                key: chex.PRNGKey,
+            ) -> tuple[jax.Array, jax.Array]:
+                return place(
+                    n_trial=self._max_place_attempts,
+                    radius=self._agent_radius,
+                    coordinate=self._coordinate,
+                    loc_fn=jax.vmap(self._agent_loc_fn, in_axes=(0, None)),
+                    shaped=self._physics.shaped,
+                    loc_state=state,
+                    key=key,
+                    stated=stated,
+                )
+
+            self._place_newborn = jax.vmap(place_newborn, in_axes=(None, None, 0))
+
+        else:
+            assert False, "Not implemented"
         if isinstance(sensor_range, SensorRange):
             sensor_range_tuple = SensorRange(sensor_range).as_tuple()
         else:
@@ -548,7 +583,7 @@ def step(
             angular_velocity=stated.circle.v.angle,
         )
         # energy_delta = food - coef * |force|
-        force_norm = jnp.sqrt(f1_raw**2 + f2_raw**2)
+        force_norm = jnp.sqrt(f1_raw**2 + f2_raw**2).ravel()
         energy_delta = food_collision - self._force_energy_consumption * force_norm
         timestep = TimeStep(encount=c2c, obs=obs)
         # Remove and reproduce foods
@@ -578,59 +613,51 @@ def step(
     def activate(
         self,
         state: CFState,
-        parent_gen: jax.Array,
-        init_energy: jax.Array,
+        is_parent: jax.Array,
     ) -> tuple[CFState, jax.Array]:
         circle = state.physics.circle
-        key, place_key = jax.random.split(state.key)
-        new_xy, ok = self._place_agent(
-            loc_state=state.agent_loc,
-            key=place_key,
-            stated=state.physics,
-        )
-        first_inactive = first_true(jnp.logical_not(circle.is_active))
-        place = jnp.logical_and(first_inactive, ok)
-        xy = jnp.where(
-            jnp.expand_dims(place, axis=1),
-            jnp.expand_dims(new_xy, axis=0),
-            circle.p.xy,
-        )
-        angle = jnp.where(place, 0.0, circle.p.angle)
+        keys = jax.random.split(state.key, self._n_max_agents + 1)
+        new_xy, ok = self._place_newborn(state.agent_loc, state.physics, keys[1:])
+        canbe_parent = jnp.logical_and(is_parent, ok)
+        slots = _first_n_true(jnp.logical_not(circle.is_active), jnp.sum(canbe_parent))
+        parents = _first_n_true(canbe_parent, jnp.sum(slots))
+        xy = circle.p.xy.at[slots].set(new_xy[parents])
+        angle = jnp.where(slots, 0.0, circle.p.angle)
         p = Position(angle=angle, xy=xy)
-        is_active = jnp.logical_or(place, circle.is_active)
+        is_active = jnp.logical_or(slots, circle.is_active)
         physics = replace(
             state.physics,
             circle=replace(circle, p=p, is_active=is_active),
         )
-        profile = state.profile.activate(
-            place,
-            parent_gen,
-            state.n_born_agents,
-            state.step,
+        profile = state.profile.activate(slots, state.step)
+        shared_energy = state.status.energy * self._energy_share_ratio
+        init_energy = (
+            jnp.zeros_like(state.status.energy).at[slots].set(shared_energy[parents])
         )
-        status = state.status.activate(place, init_energy=init_energy)
+        status = state.status.activate(slots, init_energy=init_energy)
+        status = status.update(energy_delta=(status.energy - shared_energy) * parents)
         new_state = replace(
             state,
             physics=physics,
             profile=profile,
             status=status,
-            agent_loc=state.agent_loc.increment(jnp.sum(place)),
-            n_born_agents=state.n_born_agents + jnp.sum(place),
-            key=key,
+            agent_loc=state.agent_loc.increment(jnp.sum(slots)),
+            n_born_agents=state.n_born_agents + jnp.sum(slots),
+            key=keys[0],
         )
-        return new_state, jnp.any(place)
+        return new_state, parents
 
-    def deactivate(self, state: CFState, index: Index) -> CFState:
-        p_xy = state.physics.circle.p.xy.at[index].set(self._invisible_xy)
+    def deactivate(self, state: CFState, flag: jax.Array) -> CFState:
+        p_xy = state.physics.circle.p.xy.at[flag].set(self._invisible_xy)
         p = replace(state.physics.circle.p, xy=p_xy)
-        v_xy = state.physics.circle.v.xy.at[index].set(0.0)
-        v_angle = state.physics.circle.v.angle.at[index].set(0.0)
+        v_xy = state.physics.circle.v.xy.at[flag].set(0.0)
+        v_angle = state.physics.circle.v.angle.at[flag].set(0.0)
         v = Velocity(angle=v_angle, xy=v_xy)
-        is_active = state.physics.circle.is_active.at[index].set(False)
+        is_active = state.physics.circle.is_active.at[flag].set(False)
         circle = replace(state.physics.circle, p=p, v=v, is_active=is_active)
         physics = replace(state.physics, circle=circle)
-        profile = state.profile.deactivate(index)
-        status = state.status.deactivate(index)
+        profile = state.profile.deactivate(flag)
+        status = state.status.deactivate(flag)
         return replace(state, physics=physics, profile=profile, status=status)
 
     def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
@@ -701,7 +728,7 @@ def _initialize_physics_state(
         agent_failed = 0
         agentloc_state = self._initial_foodloc_state
         for i, key in enumerate(keys[: self._n_initial_agents]):
-            xy, ok = self._place_agent(loc_state=agentloc_state, key=key, stated=stated)
+            xy, ok = self._init_agent(loc_state=agentloc_state, key=key, stated=stated)
             if ok:
                 stated = stated.nested_replace(
                     "circle.p.xy",
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index 24600fa1..be22747b 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -287,10 +287,8 @@ def place(
     shaped: ShapeDict,
     stated: StateDict,
 ) -> tuple[jax.Array, jax.Array]:
-    """Returns `[inf, inf]` if it fails"""
     keys = jax.random.split(key, n_trial)
-    vmap_loc_fn = jax.vmap(loc_fn, in_axes=(0, None))
-    locations = vmap_loc_fn(keys, loc_state)
+    locations = loc_fn(keys, loc_state)
     contains_fn = jax.vmap(coordinate.contains_circle, in_axes=(0, None))
     overlap = jax.vmap(circle_overlap, in_axes=(None, None, 0, None))(
         shaped,
diff --git a/src/emevo/status.py b/src/emevo/status.py
deleted file mode 100644
index ab87fdea..00000000
--- a/src/emevo/status.py
+++ /dev/null
@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import replace
-from typing import Any
-
-import chex
-import jax
-import jax.numpy as jnp
-
-from emevo.types import Index
-
-Self = Any
-
-
-@chex.dataclass
-class Status:
-    """Default status implementation with age and energy."""
-
-    age: jax.Array
-    energy: jax.Array
-    capacity: float = 100.0
-
-    def step(self) -> Self:
-        """Get older."""
-        return replace(self, age=self.age + 1)
-
-    def activate(self, index: Index, init_energy: jax.Array) -> Self:
-        age = self.age.at[index].set(0)
-        energy = self.energy.at[index].set(init_energy)
-        return replace(self, age=age, energy=energy)
-
-    def deactivate(self, index: Index) -> Self:
-        return replace(self, age=self.age.at[index].set(-1))
-
-    def update(self, *, energy_delta: jax.Array) -> Self:
-        """Update energy."""
-        energy = self.energy + energy_delta
-        return replace(self, energy=jnp.clip(energy, a_min=0.0, a_max=self.capacity))
-
-
-def init_status(
-    n: int,
-    max_n: int,
-    init_energy: float,
-    capacity: float = 100.0,
-) -> Status:
-    assert max_n >= n
-    return Status(
-        age=jnp.zeros(max_n, dtype=jnp.int32),
-        energy=jnp.ones(max_n, dtype=jnp.float32) * init_energy,
-        capacity=capacity,
-    )
diff --git a/src/emevo/types.py b/src/emevo/types.py
index f5aa212a..1d2079f2 100644
--- a/src/emevo/types.py
+++ b/src/emevo/types.py
@@ -1,4 +1,3 @@
-from collections.abc import Sequence
 from typing import Any, Protocol
 
 import jax
@@ -14,4 +13,3 @@ def dtype(self) -> DType:
 
 DTypeLike = DType | SupportsDType
 PyTree = Any
-Index = int | jax.Array | Sequence[int]
diff --git a/tests/test_status.py b/tests/test_status.py
index 500461d6..0fb18264 100644
--- a/tests/test_status.py
+++ b/tests/test_status.py
@@ -1,7 +1,7 @@
 import jax.numpy as jnp
 import pytest
 
-from emevo.status import init_status
+from emevo.env import init_status
 
 
 @pytest.mark.parametrize(

From b06a8ae384567f1f49180d7c9e61bc70f6992d82 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 13 Dec 2023 12:31:06 +0900
Subject: [PATCH 108/337] Place newborn in neighbor

---
 src/emevo/environments/circle_foraging.py | 49 ++++++++++++++++++++---
 src/emevo/environments/env_utils.py       | 24 +++++++----
 2 files changed, 61 insertions(+), 12 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 2309f753..fa242a31 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -32,6 +32,7 @@
     ReprNumFn,
     SquareCoordinate,
     first_true,
+    loc_gaussian,
     place,
 )
 from emevo.environments.phyjax2d import Circle, Position, Raycast, ShapeDict
@@ -312,7 +313,8 @@ def __init__(
         env_radius: float = 120.0,
         env_shape: Literal["square", "circle"] = "square",
         obstacles: list[tuple[Vec2d, Vec2d]] | str = "none",
-        newborn_loc: Literal["neighbor", "uniform"] = "uniform",
+        newborn_loc: Literal["neighbor", "uniform"] = "neighbor",
+        neighbor_stddev: float = 40.0,
         n_agent_sensors: int = 16,
         sensor_length: float = 100.0,
         sensor_range: tuple[float, float] | SensorRange = SensorRange.WIDE,
@@ -432,10 +434,11 @@ def __init__(
         )
         if newborn_loc == "uniform":
 
-            def place_newborn(
+            def place_newborn_uniform(
                 state: LocatingState,
                 stated: StateDict,
                 key: chex.PRNGKey,
+                _: jax.Array,
             ) -> tuple[jax.Array, jax.Array]:
                 return place(
                     n_trial=self._max_place_attempts,
@@ -448,10 +451,41 @@ def place_newborn(
                     stated=stated,
                 )
 
-            self._place_newborn = jax.vmap(place_newborn, in_axes=(None, None, 0))
+            self._place_newborn = jax.vmap(
+                place_newborn_uniform,
+                in_axes=(None, None, 0, None),
+            )
+
+        elif newborn_loc == "neighbor":
 
+            def place_newborn_neighbor(
+                state: LocatingState,
+                stated: StateDict,
+                key: chex.PRNGKey,
+                agent_loc: jax.Array,
+            ) -> tuple[jax.Array, jax.Array]:
+                loc_fn = loc_gaussian(
+                    agent_loc,
+                    jnp.ones_like(agent_loc) * neighbor_stddev,
+                )
+
+                return place(
+                    n_trial=self._max_place_attempts,
+                    radius=self._agent_radius,
+                    coordinate=self._coordinate,
+                    loc_fn=jax.vmap(loc_fn, in_axes=(0, None)),
+                    shaped=self._physics.shaped,
+                    loc_state=state,
+                    key=key,
+                    stated=stated,
+                )
+
+            self._place_newborn = jax.vmap(
+                place_newborn_neighbor,
+                in_axes=(None, None, 0, 0),
+            )
         else:
-            assert False, "Not implemented"
+            raise ValueError(f"Invalid newborn_loc: {newborn_loc}")
         if isinstance(sensor_range, SensorRange):
             sensor_range_tuple = SensorRange(sensor_range).as_tuple()
         else:
@@ -617,7 +651,12 @@ def activate(
     ) -> tuple[CFState, jax.Array]:
         circle = state.physics.circle
         keys = jax.random.split(state.key, self._n_max_agents + 1)
-        new_xy, ok = self._place_newborn(state.agent_loc, state.physics, keys[1:])
+        new_xy, ok = self._place_newborn(
+            state.agent_loc,
+            state.physics,
+            keys[1:],
+            circle.p.xy,
+        )
         canbe_parent = jnp.logical_and(is_parent, ok)
         slots = _first_n_true(jnp.logical_not(circle.is_active), jnp.sum(canbe_parent))
         parents = _first_n_true(canbe_parent, jnp.sum(slots))
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index be22747b..fa252764 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -277,18 +277,13 @@ def first_true(boolean_array: jax.Array) -> jax.Array:
     return jnp.logical_and(boolean_array, jnp.cumsum(boolean_array) == 1)
 
 
-def place(
-    n_trial: int,
+def place_with_loc(
     radius: float,
     coordinate: Coordinate,
-    loc_fn: LocatingFn,
-    loc_state: LocatingState,
-    key: chex.PRNGKey,
+    locations: jax.Array,
     shaped: ShapeDict,
     stated: StateDict,
 ) -> tuple[jax.Array, jax.Array]:
-    keys = jax.random.split(key, n_trial)
-    locations = loc_fn(keys, loc_state)
     contains_fn = jax.vmap(coordinate.contains_circle, in_axes=(0, None))
     overlap = jax.vmap(circle_overlap, in_axes=(None, None, 0, None))(
         shaped,
@@ -299,3 +294,18 @@ def place(
     ok = jnp.logical_and(contains_fn(locations, radius), jnp.logical_not(overlap))
     mask = jnp.expand_dims(first_true(ok), axis=1)
     return jnp.sum(mask * locations, axis=0), jnp.any(ok)
+
+
+def place(
+    n_trial: int,
+    radius: float,
+    coordinate: Coordinate,
+    loc_fn: LocatingFn,
+    loc_state: LocatingState,
+    key: chex.PRNGKey,
+    shaped: ShapeDict,
+    stated: StateDict,
+) -> tuple[jax.Array, jax.Array]:
+    keys = jax.random.split(key, n_trial)
+    locations = loc_fn(keys, loc_state)
+    return place_with_loc(radius, coordinate, locations, shaped, stated)

From 2f054b1a4862b74511f418e813534945a7b7121b Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 13 Dec 2023 13:53:30 +0900
Subject: [PATCH 109/337] Revert unnecessary changes to place

---
 src/emevo/environments/circle_foraging.py |  8 +++----
 src/emevo/environments/env_utils.py       | 26 +++++++----------------
 2 files changed, 12 insertions(+), 22 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index fa242a31..f7934714 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -418,7 +418,7 @@ def __init__(
                 n_trial=self._max_place_attempts,
                 radius=self._agent_radius,
                 coordinate=self._coordinate,
-                loc_fn=jax.vmap(self._agent_loc_fn, in_axes=(0, None)),
+                loc_fn=self._agent_loc_fn,
                 shaped=self._physics.shaped,
             )
         )
@@ -428,7 +428,7 @@ def __init__(
                 n_trial=self._max_place_attempts,
                 radius=self._food_radius,
                 coordinate=self._coordinate,
-                loc_fn=jax.vmap(self._food_loc_fn, in_axes=(0, None)),
+                loc_fn=self._food_loc_fn,
                 shaped=self._physics.shaped,
             )
         )
@@ -444,7 +444,7 @@ def place_newborn_uniform(
                     n_trial=self._max_place_attempts,
                     radius=self._agent_radius,
                     coordinate=self._coordinate,
-                    loc_fn=jax.vmap(self._agent_loc_fn, in_axes=(0, None)),
+                    loc_fn=self._agent_loc_fn,
                     shaped=self._physics.shaped,
                     loc_state=state,
                     key=key,
@@ -473,7 +473,7 @@ def place_newborn_neighbor(
                     n_trial=self._max_place_attempts,
                     radius=self._agent_radius,
                     coordinate=self._coordinate,
-                    loc_fn=jax.vmap(loc_fn, in_axes=(0, None)),
+                    loc_fn=loc_fn,
                     shaped=self._physics.shaped,
                     loc_state=state,
                     key=key,
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index fa252764..7ad0ccaf 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -277,35 +277,25 @@ def first_true(boolean_array: jax.Array) -> jax.Array:
     return jnp.logical_and(boolean_array, jnp.cumsum(boolean_array) == 1)
 
 
-def place_with_loc(
+def place(
+    n_trial: int,
     radius: float,
     coordinate: Coordinate,
-    locations: jax.Array,
+    loc_fn: LocatingFn,
+    loc_state: LocatingState,
+    key: chex.PRNGKey,
     shaped: ShapeDict,
     stated: StateDict,
 ) -> tuple[jax.Array, jax.Array]:
-    contains_fn = jax.vmap(coordinate.contains_circle, in_axes=(0, None))
+    keys = jax.random.split(key, n_trial)
+    locations = jax.vmap(loc_fn, in_axes=(0, None))(keys, loc_state)
     overlap = jax.vmap(circle_overlap, in_axes=(None, None, 0, None))(
         shaped,
         stated,
         locations,
         radius,
     )
+    contains_fn = jax.vmap(coordinate.contains_circle, in_axes=(0, None))
     ok = jnp.logical_and(contains_fn(locations, radius), jnp.logical_not(overlap))
     mask = jnp.expand_dims(first_true(ok), axis=1)
     return jnp.sum(mask * locations, axis=0), jnp.any(ok)
-
-
-def place(
-    n_trial: int,
-    radius: float,
-    coordinate: Coordinate,
-    loc_fn: LocatingFn,
-    loc_state: LocatingState,
-    key: chex.PRNGKey,
-    shaped: ShapeDict,
-    stated: StateDict,
-) -> tuple[jax.Array, jax.Array]:
-    keys = jax.random.split(key, n_trial)
-    locations = loc_fn(keys, loc_state)
-    return place_with_loc(radius, coordinate, locations, shaped, stated)

From cc653476ee39e5be8b5c180f8825f544d5b16ccd Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 13 Dec 2023 14:08:08 +0900
Subject: [PATCH 110/337] Remove unused types.py

---
 src/emevo/spaces.py |  4 +---
 src/emevo/types.py  | 15 ---------------
 2 files changed, 1 insertion(+), 18 deletions(-)
 delete mode 100644 src/emevo/types.py

diff --git a/src/emevo/spaces.py b/src/emevo/spaces.py
index c85af357..46dbb9cf 100644
--- a/src/emevo/spaces.py
+++ b/src/emevo/spaces.py
@@ -9,8 +9,6 @@
 import jax
 import jax.numpy as jnp
 
-from emevo.types import DTypeLike
-
 INSTANCE = TypeVar("INSTANCE")
 DTYPE = TypeVar("DTYPE")
 
@@ -50,7 +48,7 @@ def __init__(
         low: int | float | jax.Array,
         high: int | float | jax.Array,
         shape: Sequence[int] | None = None,
-        dtype: DTypeLike = jnp.float32,
+        dtype: jnp.dtype = jnp.float32,
     ) -> None:
         self.dtype = jnp.dtype(dtype)
 
diff --git a/src/emevo/types.py b/src/emevo/types.py
deleted file mode 100644
index 1d2079f2..00000000
--- a/src/emevo/types.py
+++ /dev/null
@@ -1,15 +0,0 @@
-from typing import Any, Protocol
-
-import jax
-
-DType = jax.numpy.dtype
-
-
-class SupportsDType(Protocol):
-    @property
-    def dtype(self) -> DType:
-        ...
-
-
-DTypeLike = DType | SupportsDType
-PyTree = Any

From 2ea28e95a7fa0fff0f8db518c6f179bbc315ca1e Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 13 Dec 2023 14:15:56 +0900
Subject: [PATCH 111/337] Add some missing 'import annotations' for Python3.9

---
 README.md                                |  2 +-
 src/emevo/environments/phyjax2d.py       | 10 ++++++++--
 src/emevo/environments/phyjax2d_utils.py |  2 ++
 3 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index de89cd23..6e684f54 100644
--- a/README.md
+++ b/README.md
@@ -34,6 +34,6 @@ nox -s tests
 ```
 
 # License
-Apache 2.0
+[Apache LICENSE 2.0][./LICENSE] holds unless otherwise noted.
 
 `vec2d.py` is copied from [PyMunk](pymunk.org) with the license-header as-is.
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 18e009d3..fe341bb1 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -1,3 +1,7 @@
+"""2D physics simulator based on jax"""
+
+from __future__ import annotations
+
 import dataclasses
 import functools
 import uuid
@@ -9,7 +13,6 @@
 import jax
 import jax.numpy as jnp
 
-Axis = Sequence[int] | int
 Self = Any
 
 
@@ -20,7 +23,10 @@ def then(x: Any, f: Callable[[Any], Any]) -> Any:
         return f(x)
 
 
-def normalize(x: jax.Array, axis: Axis | None = None) -> tuple[jax.Array, jax.Array]:
+def normalize(
+    x: jax.Array,
+    axis: Sequence[int] | int | None = None,
+) -> tuple[jax.Array, jax.Array]:
     norm = jnp.linalg.norm(x, axis=axis)
     n = x / jnp.clip(norm, a_min=1e-6)
     return n, norm
diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 5f640d51..442c91aa 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import dataclasses
 import warnings
 from typing import Any, Callable, NamedTuple

From 0933e56afffb0ad9e64d8fe3282eb5233c97a22f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 13 Dec 2023 15:17:24 +0900
Subject: [PATCH 112/337] Fix ruff errors

---
 pyproject.toml                         |  6 +++++
 smoke-tests/circle_loop.py             |  4 +++-
 src/emevo/environments/__init__.py     |  2 +-
 src/emevo/environments/moderngl_vis.py | 31 +++++++++++++++++++++++++-
 src/emevo/exp_utils.py                 |  2 +-
 src/emevo/rl/ppo_normal.py             |  2 +-
 tests/test_ppo.py                      |  1 -
 7 files changed, 42 insertions(+), 6 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index f9890c13..54fde431 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -57,7 +57,13 @@ profile = "black"
 
 [tool.ruff]
 line-length = 88
+# ignore = ["UP035"]
 select = ["E", "F", "B", "UP"]
 
 [tool.ruff.per-file-ignores]
 "__init__.py" = ["F401"]
+# For pyserde
+"src/emevo/exp_utils.py" = ["UP006", "UP035"]
+# For typer
+"experiments/**/*.py" = ["B008", "UP006", "UP007"]
+"smoke-tests/*.py" = ["B008", "UP006", "UP007"]
\ No newline at end of file
diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index 3f7de156..232c8f65 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -79,7 +79,9 @@ def main(
 
         if replace and i % replace_interval == 0:
             if i < steps // 2:
-                flag = jnp.zeros(n_max_agents, dtype=bool).at[deactivate_index].set(True)
+                flag = (
+                    jnp.zeros(n_max_agents, dtype=bool).at[deactivate_index].set(True)
+                )
                 state = env.deactivate(state, flag)
                 deactivate_index -= 1
             else:
diff --git a/src/emevo/environments/__init__.py b/src/emevo/environments/__init__.py
index e9e57352..a4653adc 100644
--- a/src/emevo/environments/__init__.py
+++ b/src/emevo/environments/__init__.py
@@ -1,8 +1,8 @@
 """ Implementation of registry and built-in emevo environments.
 """
 
-from emevo.environments.registry import description, make, register
 from emevo.environments.circle_foraging import CircleForaging
+from emevo.environments.registry import description, make, register
 
 register(
     "CircleForaging-v0",
diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index a50f6a6a..9822587a 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -282,6 +282,33 @@ def _collect_heads(circle: Circle, state: State) -> NDArray:
     return np.concatenate((p1, p2), axis=1).reshape(-1, 2)
 
 
+# def _collect_policies(
+#     circle: Circle,
+#     state: State,
+#     max_arrow_length: float,
+# ) -> NDArray:
+# max_f = max(map(lambda bp: bp[1].max(), bodies_and_policies))
+# policy_scaling = max_arrow_length / max_f
+# points = []
+# radius = None
+# for body, policy in bodies_and_policies:
+#     a = body.position
+#     if radius is None:
+#         radius = next(
+#             filter(lambda shape: isinstance(shape, pymunk.Circle), body.shapes)
+#         ).radius
+#     f1, f2 = policy
+#     from1 = a + pymunk.Vec2d(0, radius).rotated(body.angle + np.pi * 0.75)
+#     to1 = from1 + pymunk.Vec2d(0, -f1 * policy_scaling).rotated(body.angle)
+#     from2 = a + pymunk.Vec2d(0, radius).rotated(body.angle - np.pi * 0.75)
+#     to2 = from2 + pymunk.Vec2d(0, -f2 * policy_scaling).rotated(body.angle)
+#     points.append(from1)
+#     points.append(to1)
+#     points.append(from2)
+#     points.append(to2)
+# return np.array(points, dtype=np.float32)
+
+
 def _get_clip_ranges(lengthes: list[float]) -> list[tuple[float, float]]:
     """Clip ranges to [-1, 1]"""
     total = sum(lengthes)
@@ -435,7 +462,9 @@ def overlay(self, name: str, value: Any) -> Any:
         """Render additional value as an overlay"""
         key = name.lower()
         if key == "arrow":
-            segments = _collect_policies(value, self._range_min * 0.1)
+            # Not implmented yet
+            # segments = _collect_policies(value, self._range_min * 0.1)
+            segments = np.zeros(1)
             if "arrow" in self._overlays:
                 do_render = self._overlays["arrow"].update(segments)
             else:
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 64c6ac3a..8a8f8fdf 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -18,7 +18,7 @@ class CfConfig:
     n_agent_sensors: int
     sensor_length: float
     food_loc_fn: str
-    food_num_fn: Tuple["str", int]
+    food_num_fn: Tuple[str, int]
     xlim: Tuple[float, float]
     ylim: Tuple[float, float]
     env_radius: float
diff --git a/src/emevo/rl/ppo_normal.py b/src/emevo/rl/ppo_normal.py
index efe4d555..d9ed5a0c 100644
--- a/src/emevo/rl/ppo_normal.py
+++ b/src/emevo/rl/ppo_normal.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import cast, NamedTuple
+from typing import NamedTuple, cast
 
 import chex
 import distrax
diff --git a/tests/test_ppo.py b/tests/test_ppo.py
index b99b1e72..c95a7190 100644
--- a/tests/test_ppo.py
+++ b/tests/test_ppo.py
@@ -6,7 +6,6 @@
 import pytest
 
 from emevo.rl.ppo_normal import (
-    Batch,
     NormalPPONet,
     Rollout,
     get_minibatches,

From 2be72d940c2081857c4b89664156e687ef229924 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 13 Dec 2023 15:20:05 +0900
Subject: [PATCH 113/337] Don't import make and register in
 environments/__init__.py

---
 src/emevo/__init__.py              | 2 +-
 src/emevo/environments/__init__.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/emevo/__init__.py b/src/emevo/__init__.py
index 2a9e858f..149781df 100644
--- a/src/emevo/__init__.py
+++ b/src/emevo/__init__.py
@@ -5,7 +5,7 @@
 
 
 from emevo.env import Env, Profile, Status, TimeStep
-from emevo.environments import make, register
+from emevo.environments.registry import make, register
 from emevo.vec2d import Vec2d
 from emevo.visualizer import Visualizer
 
diff --git a/src/emevo/environments/__init__.py b/src/emevo/environments/__init__.py
index a4653adc..6a8661a1 100644
--- a/src/emevo/environments/__init__.py
+++ b/src/emevo/environments/__init__.py
@@ -2,7 +2,7 @@
 """
 
 from emevo.environments.circle_foraging import CircleForaging
-from emevo.environments.registry import description, make, register
+from emevo.environments.registry import register
 
 register(
     "CircleForaging-v0",

From 77179293278fada7600dad100af586f4966fbad7 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 13 Dec 2023 17:23:50 +0900
Subject: [PATCH 114/337] Return parents from env.activate

---
 experiments/cf_asexual_evo.py             | 23 +++++++++++++++++++++--
 smoke-tests/circle_loop.py                |  6 ++----
 src/emevo/env.py                          |  7 ++-----
 src/emevo/environments/circle_foraging.py | 23 +++++++++++++++--------
 4 files changed, 40 insertions(+), 19 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 3655cd06..a46a873c 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -11,7 +11,9 @@
 import optax
 import typer
 
-from emevo import Env, make
+from emevo import Env
+from emevo import birth_and_death as bd
+from emevo import make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
 from emevo.rl.ppo_normal import (
@@ -78,12 +80,19 @@ def step(key: chex.PRNGKey, state: State, obs: Obs) -> tuple[State, Obs, jax.Arr
         visualizer.show()
 
 
+@chex.dataclass
+class Record:
+    parents: jax.Array
+
+
 def exec_rollout(
     state: State,
     initial_obs: Obs,
     env: Env,
     network: NormalPPONet,
     reward_fn: LinearReward,
+    hazard_fn: bd.HazardFunction,
+    birth_fn: bd.BirthFunction,
     prng_key: jax.Array,
     n_rollout_steps: int,
 ) -> tuple[State, Rollout, Obs, jax.Array]:
@@ -107,7 +116,17 @@ def step_rollout(
             means=net_out.mean,
             logstds=net_out.logstd,
         )
-        return (state_t1, timestep.obs), rollout
+        # Birth and death
+        death_prob = hazard_fn(state_t1.status.age, state_t1.status.energy)
+        dead = jax.random.bernoulli(hazard_key, p=death_prob)
+        state_t1d = env.deactivate(state_t1, dead)
+        birth_prob = birth_fn(state_t1d.status.age, state_t1d.status.energy)
+        possible_parents = jnp.logical_and(
+            jnp.logical_not(dead),
+            jax.random.bernoulli(birth_key, p=birth_prob),
+        )
+        state_t1db, parents = env.activate(state_t1d, possible_parents)
+        return (state_t1db, timestep.obs), rollout
 
     (state, obs), rollout = jax.lax.scan(
         step_rollout,
diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index 232c8f65..e1d00984 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -86,10 +86,8 @@ def main(
                 deactivate_index -= 1
             else:
                 flag = jax.random.bernoulli(keys[i + 1], p=activate_p)
-                state, success = env.activate(state, flag)
-                for idx in range(n_max_agents):
-                    if flag[idx] and not success[idx]:
-                        print(f"Failed to activate agent for a parent {idx}")
+                state, parents = env.activate(state, flag)
+                print("Parents: ", parents)
 
         if visualizer is not None:
             visualizer.render(state)
diff --git a/src/emevo/env.py b/src/emevo/env.py
index c52e5981..e536cb28 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -161,16 +161,13 @@ def activate(
         state: STATE,
         is_parent: jax.Array,
     ) -> tuple[STATE, jax.Array]:
-        """
-        Mark an agent or some agents active.
-        This method fails if there isn't enough space, returning (STATE, False).
-        """
+        """Mark some agents active, if possible."""
         pass
 
     @abc.abstractmethod
     def deactivate(self, state: STATE, flag: jax.Array) -> STATE:
         """
-        Deactivate an agent or some agents. The shape of observations should remain the
+        Deactivate some agents. The shape of observations should remain the
         same so that `Env.step` is compiled onle once. So, to represent that an agent is
         dead, it is recommended to mark that body is not active and reuse it after a new
         agent is born.
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index f7934714..593ed11d 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -657,9 +657,12 @@ def activate(
             keys[1:],
             circle.p.xy,
         )
-        canbe_parent = jnp.logical_and(is_parent, ok)
-        slots = _first_n_true(jnp.logical_not(circle.is_active), jnp.sum(canbe_parent))
-        parents = _first_n_true(canbe_parent, jnp.sum(slots))
+        possible_parents = jnp.logical_and(is_parent, ok)
+        slots = _first_n_true(
+            jnp.logical_not(circle.is_active),
+            jnp.sum(possible_parents),
+        )
+        parents = _first_n_true(possible_parents, jnp.sum(slots))
         xy = circle.p.xy.at[slots].set(new_xy[parents])
         angle = jnp.where(slots, 0.0, circle.p.angle)
         p = Position(angle=angle, xy=xy)
@@ -684,7 +687,9 @@ def activate(
             n_born_agents=state.n_born_agents + jnp.sum(slots),
             key=keys[0],
         )
-        return new_state, parents
+        empty_id = jnp.ones_like(state.profile.unique_id) * -1
+        parents_id = empty_id.at[slots].set(state.profile.unique_id[parents])
+        return new_state, parents_id
 
     def deactivate(self, state: CFState, flag: jax.Array) -> CFState:
         p_xy = state.physics.circle.p.xy.at[flag].set(self._invisible_xy)
@@ -701,10 +706,11 @@ def deactivate(self, state: CFState, flag: jax.Array) -> CFState:
 
     def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
         physics, agent_loc, food_loc = self._initialize_physics_state(key)
-        profile = init_profile(self._n_initial_agents, self._n_max_agents)
+        nmax = self._n_max_agents
+        profile = init_profile(self._n_initial_agents, nmax)
         status = init_status(
             self._n_initial_agents,
-            self._n_max_agents,
+            nmax,
             self._init_energy,
             self._energy_capacity,
         )
@@ -723,12 +729,13 @@ def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
         sensor_obs = self._sensor_obs(stated=physics)
         obs = CFObs(
             sensor=sensor_obs.reshape(-1, self._n_sensors, N_OBJECTS),
-            collision=jnp.zeros((self._n_max_agents, N_OBJECTS), dtype=bool),
+            collision=jnp.zeros((nmax, N_OBJECTS), dtype=bool),
             angle=physics.circle.p.angle,
             velocity=physics.circle.v.xy,
             angular_velocity=physics.circle.v.angle,
         )
-        timestep = TimeStep(encount=None, obs=obs)
+        # They shouldn't encount now
+        timestep = TimeStep(encount=jnp.zeros((nmax, nmax), dtype=bool), obs=obs)
         return state, timestep
 
     def _initialize_physics_state(

From 073a1f6f1f63937f34a7ad316c96c35070ebe496 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 14 Dec 2023 12:24:46 +0900
Subject: [PATCH 115/337] Python 3.9

---
 src/emevo/environments/phyjax2d_utils.py | 6 +++---
 src/emevo/vec2d.py                       | 5 +----
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/emevo/environments/phyjax2d_utils.py b/src/emevo/environments/phyjax2d_utils.py
index 442c91aa..5a9866a3 100644
--- a/src/emevo/environments/phyjax2d_utils.py
+++ b/src/emevo/environments/phyjax2d_utils.py
@@ -20,7 +20,7 @@
     _vmap_dot,
     empty,
 )
-from emevo.vec2d import Vec2d, Vec2dLike
+from emevo.vec2d import Vec2d
 
 Self = Any
 
@@ -101,7 +101,7 @@ class SpaceBuilder:
     Not expected to used with `jax.jit`.
     """
 
-    gravity: Vec2dLike = dataclasses.field(default=(0.0, -9.8))
+    gravity: Vec2d | tuple[float, float] = dataclasses.field(default=(0.0, -9.8))
     circles: list[Circle] = dataclasses.field(default_factory=list)
     static_circles: list[Circle] = dataclasses.field(default_factory=list)
     capsules: list[Capsule] = dataclasses.field(default_factory=list)
@@ -284,7 +284,7 @@ def build(self) -> Space:
 
 
 def make_approx_circle(
-    center: Vec2dLike,
+    center: Vec2d | tuple[float, float],
     radius: float,
     n_lines: int = 32,
 ) -> list[tuple[Vec2d, Vec2d]]:
diff --git a/src/emevo/vec2d.py b/src/emevo/vec2d.py
index 6ee2e344..fb0c9ce1 100644
--- a/src/emevo/vec2d.py
+++ b/src/emevo/vec2d.py
@@ -58,7 +58,7 @@
 import operator
 from typing import Any, NamedTuple
 
-__all__ = ["Vec2d", "Vec2dLike"]
+__all__ = ["Vec2d"]
 
 Self = Any
 
@@ -412,6 +412,3 @@ def cpvunrotate(self, other: tuple[float, float]) -> Self:
         return Vec2d(
             self.x * other[0] + self.y * other[1], self.y * other[0] - self.x * other[1]
         )
-
-
-Vec2dLike = Vec2d | tuple[float, float]

From efed901d347daf7b97eb76f3037e620269b062cc Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 14 Dec 2023 17:43:38 +0900
Subject: [PATCH 116/337] Log schema

---
 config/20230530-a035-e020.toml            |  2 +-
 experiments/cf_asexual_evo.py             | 95 +++++++++--------------
 src/emevo/env.py                          | 13 +---
 src/emevo/environments/circle_foraging.py | 12 ++-
 src/emevo/exp_utils.py                    | 38 +++++++++
 tests/test_status.py                      |  6 +-
 6 files changed, 86 insertions(+), 80 deletions(-)

diff --git a/config/20230530-a035-e020.toml b/config/20230530-a035-e020.toml
index f862b695..cf8bb224 100644
--- a/config/20230530-a035-e020.toml
+++ b/config/20230530-a035-e020.toml
@@ -11,4 +11,4 @@ e0 = 0.0
 [birth_params]
 alpha = 0.1
 scale = 2e-4
-e0 = 20.0.
\ No newline at end of file
+e0 = 20.0
diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index a46a873c..ba13fb85 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -1,7 +1,7 @@
 """Example of using circle foraging environment"""
 
 from pathlib import Path
-from typing import Optional
+from typing import Literal, Optional
 
 import chex
 import equinox as eqx
@@ -10,12 +10,14 @@
 import numpy as np
 import optax
 import typer
+from fastavro import parse_schema, writer
 
 from emevo import Env
 from emevo import birth_and_death as bd
 from emevo import make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
+from emevo.exp_utils import Log
 from emevo.rl.ppo_normal import (
     NormalPPONet,
     Rollout,
@@ -80,11 +82,6 @@ def step(key: chex.PRNGKey, state: State, obs: Obs) -> tuple[State, Obs, jax.Arr
         visualizer.show()
 
 
-@chex.dataclass
-class Record:
-    parents: jax.Array
-
-
 def exec_rollout(
     state: State,
     initial_obs: Obs,
@@ -95,11 +92,11 @@ def exec_rollout(
     birth_fn: bd.BirthFunction,
     prng_key: jax.Array,
     n_rollout_steps: int,
-) -> tuple[State, Rollout, Obs, jax.Array]:
+) -> tuple[State, Rollout, Log, Obs, jax.Array]:
     def step_rollout(
         carried: tuple[State, Obs],
         key: jax.Array,
-    ) -> tuple[tuple[State, Obs], Rollout]:
+    ) -> tuple[tuple[State, Obs], tuple[Rollout, Log]]:
         act_key, hazard_key, birth_key = jax.random.split(key, 3)
         state_t, obs_t = carried
         obs_t_array = obs_t.as_array()
@@ -126,23 +123,35 @@ def step_rollout(
             jax.random.bernoulli(birth_key, p=birth_prob),
         )
         state_t1db, parents = env.activate(state_t1d, possible_parents)
-        return (state_t1db, timestep.obs), rollout
+        log = Log(
+            parents=parents,
+            rewards=rewards,
+            age=state_t1db.status.age,
+            energy=state_t1db.status.energy,
+            birthtime=state_t1db.profile.birthtime,
+            generation=state_t1db.profile.generation,
+            unique_id=state_t1db.profile.unique_id,
+        )
+        return (state_t1db, timestep.obs), (rollout, log)
 
-    (state, obs), rollout = jax.lax.scan(
+    (state, obs), (rollout, log) = jax.lax.scan(
         step_rollout,
         (state, initial_obs),
         jax.random.split(prng_key, n_rollout_steps),
     )
     next_value = vmap_value(network, obs.as_array())
-    return state, rollout, obs, next_value
+    return state, rollout, log, obs, next_value
 
 
 @eqx.filter_jit
-def training_step(
+def epoch(
     state: State,
     initial_obs: Obs,
     env: Env,
     network: NormalPPONet,
+    reward_fn: LinearReward,
+    hazard_fn: bd.HazardFunction,
+    birth_fn: bd.BirthFunction,
     prng_key: jax.Array,
     n_rollout_steps: int,
     gamma: float,
@@ -151,20 +160,20 @@ def training_step(
     opt_state: optax.OptState,
     minibatch_size: int,
     n_optim_epochs: int,
-    reset: jax.Array,
 ) -> tuple[State, Obs, jax.Array, optax.OptState, NormalPPONet]:
     keys = jax.random.split(prng_key, N_MAX_AGENTS + 1)
-    env_state, rollout, obs, next_value = exec_rollout(
+    env_state, rollout, log, obs, next_value = exec_rollout(
         state,
         initial_obs,
         env,
         network,
+        reward_fn,
+        hazard_fn,
+        birth_fn,
         keys[0],
         n_rollout_steps,
     )
-    rollout = rollout.replace(terminations=rollout.terminations.at[-1].set(reset))
     batch = vmap_batch(rollout, next_value, gamma, gae_lambda)
-    output = vmap_apply(network, obs.as_array())
     opt_state, pponet = vmap_update(
         batch,
         network,
@@ -179,7 +188,7 @@ def training_step(
     return env_state, obs, rollout.rewards, opt_state, pponet
 
 
-def run_training(
+def run_evolution(
     key: jax.Array,
     n_agents: int,
     env: Env,
@@ -190,7 +199,6 @@ def run_training(
     minibatch_size: int,
     n_rollout_steps: int,
     n_total_steps: int,
-    reset_interval: int | None = None,
     debug_vis: bool = False,
 ) -> NormalPPONet:
     key, net_key, reset_key = jax.random.split(key, 3)
@@ -216,8 +224,7 @@ def run_training(
     else:
         visualizer = None
     for i, key in enumerate(keys):
-        reset = reset_interval is not None and (i + 1) % reset_interval
-        env_state, obs, rewards_i, opt_state, pponet = training_step(
+        env_state, obs, rewards_i, opt_state, pponet = epoch(
             env_state,
             obs,
             env,
@@ -230,7 +237,6 @@ def run_training(
             opt_state,
             minibatch_size,
             n_optim_epochs,
-            jnp.array(reset),
         )
         ri = jnp.sum(jnp.squeeze(rewards_i, axis=-1), axis=0)
         rewards = rewards + ri
@@ -238,24 +244,19 @@ def run_training(
             visualizer.render(env_state)
             visualizer.show()
             print(f"Rewards: {[x.item() for x in ri[: n_agents]]}")
-        if reset:
-            env_state, timestep = env.reset(key)
-            obs = timestep.obs
         # weight_summary(pponet)
     print(f"Sum of rewards {[x.item() for x in rewards[: n_agents]]}")
     return pponet
 
 
 app = typer.Typer(pretty_exceptions_show_locals=False)
+here = Path(__file__)
 
 
 @app.command()
-def train(
-    modelpath: Path = Path("trained.eqx"),
+def evolve(
     seed: int = 1,
     n_agents: int = 2,
-    n_foods: int = 10,
-    obstacles: str = "none",
     adam_lr: float = 3e-4,
     adam_eps: float = 1e-7,
     gamma: float = 0.999,
@@ -264,37 +265,14 @@ def train(
     minibatch_size: int = 128,
     n_rollout_steps: int = 1024,
     n_total_steps: int = 1024 * 1000,
-    food_loc_fn: str = "gaussian",
-    env_shape: str = "circle",
-    reset_interval: Optional[int] = None,
-    xlim: int = 200,
-    ylim: int = 200,
-    linear_damping: float = 0.8,
-    angular_damping: float = 0.6,
-    max_force: float = 40.0,
-    min_force: float = -20.0,
+    cfconfig: Path = here.joinpath("../config/"),
+    bdconfig: Path = here.joinpath("../config/bd-20230530-a035-e020.toml"),
+    reward_fn: Literal["linear", "sigmoid"] = "linear",
+    logdir: Path = Path("./log"),
     debug_vis: bool = False,
 ) -> None:
-    assert n_agents < N_MAX_AGENTS
-    env = make(
-        "CircleForaging-v0",
-        env_shape=env_shape,
-        n_max_agents=N_MAX_AGENTS,
-        n_initial_agents=n_agents,
-        food_num_fn=("constant", n_foods),
-        food_loc_fn=food_loc_fn,
-        agent_loc_fn="gaussian",
-        foodloc_interval=20,
-        obstacles=obstacles,
-        xlim=(0.0, float(xlim)),
-        ylim=(0.0, float(ylim)),
-        env_radius=min(xlim, ylim) * 0.5,
-        linear_damping=linear_damping,
-        angular_damping=angular_damping,
-        max_force=max_force,
-        min_force=min_force,
-    )
-    network = run_training(
+    env = make("CircleForaging-v0")
+    network = run_evolution(
         jax.random.PRNGKey(seed),
         n_agents,
         env,
@@ -305,10 +283,9 @@ def train(
         minibatch_size,
         n_rollout_steps,
         n_total_steps,
-        reset_interval,
         debug_vis,
     )
-    eqx.tree_serialise_leaves(modelpath, network)
+    # eqx.tree_serialise_leaves(modelpath, network)
 
 
 @app.command()
diff --git a/src/emevo/env.py b/src/emevo/env.py
index e536cb28..102486c5 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -23,7 +23,6 @@ class Status:
 
     age: jax.Array
     energy: jax.Array
-    capacity: float = 100.0
 
     def step(self) -> Self:
         """Get older."""
@@ -37,23 +36,17 @@ def activate(self, flag: jax.Array, init_energy: jax.Array) -> Self:
     def deactivate(self, flag: jax.Array) -> Self:
         return replace(self, age=jnp.where(flag, -1, self.age))
 
-    def update(self, *, energy_delta: jax.Array) -> Self:
+    def update(self, energy_delta: jax.Array, capacity: float | None = 100.0) -> Self:
         """Update energy."""
         energy = self.energy + energy_delta
-        return replace(self, energy=jnp.clip(energy, a_min=0.0, a_max=self.capacity))
+        return replace(self, energy=jnp.clip(energy, a_min=0.0, a_max=capacity))
 
 
-def init_status(
-    n: int,
-    max_n: int,
-    init_energy: float,
-    capacity: float = 100.0,
-) -> Status:
+def init_status(n: int, max_n: int, init_energy: float) -> Status:
     assert max_n >= n
     return Status(
         age=jnp.zeros(max_n, dtype=jnp.int32),
         energy=jnp.ones(max_n, dtype=jnp.float32) * init_energy,
-        capacity=capacity,
     )
 
 
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 593ed11d..ffc8a321 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -629,7 +629,10 @@ def step(
             state.food_num,
             state.food_loc,
         )
-        status = state.status.update(energy_delta=energy_delta)
+        status = state.status.update(
+            energy_delta=energy_delta,
+            capacity=self._energy_capacity,
+        )
         state = CFState(
             physics=stated,
             solver=solver,
@@ -708,12 +711,7 @@ def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
         physics, agent_loc, food_loc = self._initialize_physics_state(key)
         nmax = self._n_max_agents
         profile = init_profile(self._n_initial_agents, nmax)
-        status = init_status(
-            self._n_initial_agents,
-            nmax,
-            self._init_energy,
-            self._energy_capacity,
-        )
+        status = init_status(self._n_initial_agents, nmax, self._init_energy)
         state = CFState(
             physics=physics,
             solver=self._physics.init_solver(),
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 8a8f8fdf..19764a75 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -5,9 +5,13 @@
 import importlib
 from typing import Dict, List, Tuple, Type
 
+import chex
+import fastavro
+import jax
 import serde
 
 from emevo import birth_and_death as bd
+from emevo.env import Profile, Status
 
 
 @serde.serde
@@ -51,3 +55,37 @@ def load_models(self) -> tuple[bd.BirthFunction, bd.HazardFunction]:
         birth_fn = _load_cls(self.birth_fn)(**self.birth_params)
         hazard_fn = _load_cls(self.hazard_fn)(**self.hazard_params)
         return birth_fn, hazard_fn
+
+
+@chex.dataclass
+class Log:
+    parents: jax.Array
+    rewards: jax.Array
+    age: jax.Array
+    energy: jax.Array
+    birthtime: jax.Array
+    generation: jax.Array
+    unique_id: jax.Array
+
+    @staticmethod
+    def avro_schema() -> dict:
+        """Apache avro schema for this class"""
+
+        def array(dtype: str) -> dict[str, str]:
+            return {"type": "array", "items": dtype}
+
+        return {
+            "doc": "Default log schema for emevo",
+            "name": "Log",
+            "namespace": "emevo",
+            "type": "record",
+            "fields": [
+                {"name": "parents", "type": array("int")},
+                {"name": "rewards", "type": array("float")},
+                {"name": "energy", "type": array("float")},
+                {"name": "age", "type": array("int")},
+                {"name": "birthtime", "type": array("int")},
+                {"name": "generation", "type": array("int")},
+                {"name": "unique_id", "type": array("int")},
+            ],
+        }
diff --git a/tests/test_status.py b/tests/test_status.py
index 0fb18264..de1e23c1 100644
--- a/tests/test_status.py
+++ b/tests/test_status.py
@@ -9,13 +9,13 @@
     [(1, 10.0), (1, 100.0), (10, 10.0), (10, 100.0)],
 )
 def test_status_clipping(n: int, capacity: float) -> None:
-    status = init_status(n=n, max_n=n, init_energy=0.0, capacity=capacity)
+    status = init_status(n=n, max_n=n, init_energy=0.0)
     for _ in range(200):
-        status.update(energy_delta=jnp.ones(n))
+        status.update(energy_delta=jnp.ones(n), capacity=capacity)
         assert jnp.all(status.energy >= 0.0)
         assert jnp.all(status.energy <= capacity)
 
     for _ in range(300):
-        status.update(energy_delta=jnp.ones(n) * -1.0)
+        status.update(energy_delta=jnp.ones(n) * -1.0, capacity=capacity)
         assert jnp.all(status.energy >= 0.0)
         assert jnp.all(status.energy <= capacity)

From 695e0d9c7379e5085e0939de2bdc4aec4dab312e Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 14 Dec 2023 18:01:58 +0900
Subject: [PATCH 117/337] Env config

---
 config/{ => bd}/20230530-a035-e020.toml | 0
 experiments/cf_asexual_evo.py           | 4 ++--
 scripts/plot_bd_models.py               | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)
 rename config/{ => bd}/20230530-a035-e020.toml (100%)

diff --git a/config/20230530-a035-e020.toml b/config/bd/20230530-a035-e020.toml
similarity index 100%
rename from config/20230530-a035-e020.toml
rename to config/bd/20230530-a035-e020.toml
diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index ba13fb85..275b2f06 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -265,8 +265,8 @@ def evolve(
     minibatch_size: int = 128,
     n_rollout_steps: int = 1024,
     n_total_steps: int = 1024 * 1000,
-    cfconfig: Path = here.joinpath("../config/"),
-    bdconfig: Path = here.joinpath("../config/bd-20230530-a035-e020.toml"),
+    cfconfig: Path = here.joinpath("../config/env/20231214-square.toml"),
+    bdconfig: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
     reward_fn: Literal["linear", "sigmoid"] = "linear",
     logdir: Path = Path("./log"),
     debug_vis: bool = False,
diff --git a/scripts/plot_bd_models.py b/scripts/plot_bd_models.py
index d35388cb..6e67a1a3 100644
--- a/scripts/plot_bd_models.py
+++ b/scripts/plot_bd_models.py
@@ -18,7 +18,7 @@
 
 
 def plot_bd_models(
-    config: Path = Path("config/20230530-a035-e020.toml"),
+    config: Path = Path("config/bd/20230530-a035-e020.toml"),
     age_max: int = 200000,
     energy_max: float = 40,
     survivorship_energy: float = 10.0,

From d581cf7d2d0f24ac31464aba1599c580184c5a32 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 15 Dec 2023 12:59:08 +0900
Subject: [PATCH 118/337] Reasonable default growth rate for logistic

---
 experiments/cf_asexual_evo.py             |  4 ++--
 smoke-tests/circle_loop.py                | 10 +++++++++-
 src/emevo/environments/circle_foraging.py |  2 +-
 3 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 275b2f06..79c45b8e 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -160,7 +160,7 @@ def epoch(
     opt_state: optax.OptState,
     minibatch_size: int,
     n_optim_epochs: int,
-) -> tuple[State, Obs, jax.Array, optax.OptState, NormalPPONet]:
+) -> tuple[State, Obs, Log, optax.OptState, NormalPPONet]:
     keys = jax.random.split(prng_key, N_MAX_AGENTS + 1)
     env_state, rollout, log, obs, next_value = exec_rollout(
         state,
@@ -185,7 +185,7 @@ def epoch(
         0.2,
         0.0,
     )
-    return env_state, obs, rollout.rewards, opt_state, pponet
+    return env_state, obs, log, opt_state, pponet
 
 
 def run_evolution(
diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index e1d00984..82bb0d30 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -22,6 +22,8 @@ def main(
     fixed_agent_loc: bool = False,
     env_shape: str = "square",
     food_loc_fn: str = "gaussian",
+    food_num_fn: str = "constant",
+    food_growth_rate: float = 0.1,
 ) -> None:
     if fixed_agent_loc:
         additional_kwargs = {
@@ -39,12 +41,18 @@ def main(
         additional_kwargs = {}
 
     n_max_agents = n_agents + 10
+    if food_num_fn == "constant":
+        fnf = "constant", n_foods
+    elif food_num_fn == "logistic":
+        fnf = "logistic", n_foods, food_growth_rate, n_foods * 2
+    else:
+        raise ValueError(f"Invalid food_num_fn: {food_num_fn}")
     env = make(
         "CircleForaging-v0",
         env_shape=env_shape,
         n_max_agents=n_max_agents,
         n_initial_agents=n_agents,
-        food_num_fn=("constant", n_foods),
+        food_num_fn=fnf,
         food_loc_fn=food_loc_fn,
         foodloc_interval=20,
         obstacles=obstacles,
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index ffc8a321..e8b32b72 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -518,7 +518,7 @@ def _make_food_num_fn(
         return _get_num_or_loc_fn(
             food_num_fn,
             ReprNum,  # type: ignore
-            {"constant": (10,), "linear": (10, 0.01), "logistic": (8, 1.2, 12)},
+            {"constant": (10,), "linear": (10, 0.01), "logistic": (8, 0.01, 12)},
         )
 
     def _make_food_loc_fn(

From 672442ebed838433eb3940a790a237ec10d2b37a Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 15 Dec 2023 13:45:53 +0900
Subject: [PATCH 119/337] sensor

---
 smoke-tests/circle_ppo.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index ae579014..f9a72c87 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -230,6 +230,8 @@ def train(
     minibatch_size: int = 128,
     n_rollout_steps: int = 1024,
     n_total_steps: int = 1024 * 1000,
+    n_sensors: int = 16,
+    sensor_length: float = 100.0,
     food_loc_fn: str = "gaussian",
     env_shape: str = "circle",
     reset_interval: Optional[int] = None,
@@ -259,6 +261,8 @@ def train(
         angular_damping=angular_damping,
         max_force=max_force,
         min_force=min_force,
+        n_agent_sensors=n_sensors,
+        sensor_length=sensor_length,
     )
     network = run_training(
         jax.random.PRNGKey(seed),

From 054ad2f202dc4cc49c1abf8a8532b65b0e9214df Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 15 Dec 2023 15:14:46 +0900
Subject: [PATCH 120/337] Sensor params for vis

---
 smoke-tests/circle_ppo.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index f9a72c87..8d191845 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -298,6 +298,8 @@ def vis(
     angular_damping: float = 0.6,
     max_force: float = 40.0,
     min_force: float = -20.0,
+    n_sensors: int = 16,
+    sensor_length: float = 100.0,
     headless: bool = False,
 ) -> None:
     assert n_agents < N_MAX_AGENTS
@@ -315,6 +317,8 @@ def vis(
         env_radius=min(xlim, ylim) * 0.5,
         linear_damping=linear_damping,
         angular_damping=angular_damping,
+        n_agent_sensors=n_sensors,
+        sensor_length=sensor_length,
         max_force=max_force,
         min_force=min_force,
     )

From 6ea7352cf53ca761e4033808e3162d87ffa7aff8 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 15 Dec 2023 17:20:31 +0900
Subject: [PATCH 121/337] setup-venv

---
 config/env/20231214-square.toml | 30 +++++++++++++++++++
 experiments/cf_asexual_evo.py   | 51 ++++++++++++++++++++++-----------
 setup-venv                      | 15 ++++++++++
 src/emevo/exp_utils.py          |  1 -
 4 files changed, 80 insertions(+), 17 deletions(-)
 create mode 100644 config/env/20231214-square.toml
 create mode 100755 setup-venv

diff --git a/config/env/20231214-square.toml b/config/env/20231214-square.toml
new file mode 100644
index 00000000..12b31c5d
--- /dev/null
+++ b/config/env/20231214-square.toml
@@ -0,0 +1,30 @@
+n_initial_agents = 20
+n_max_agents = 100
+n_max_foods = 20
+food_num_fn = ["logistic", 0.01, 20]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 360.0]
+ylim = [0.0, 240.0]
+env_radius = 120.0
+env_shape = "square"
+neighbor_stddev = 40.0
+n_agent_sensors = 16
+sensor_length = 100.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 20.0
+energy_capacity = 100.0
+force_energy_consumption = 0.01 / 40.0
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 79c45b8e..1308ef2a 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -1,7 +1,7 @@
 """Example of using circle foraging environment"""
-
+import dataclasses
 from pathlib import Path
-from typing import Literal, Optional
+from typing import Literal
 
 import chex
 import equinox as eqx
@@ -11,13 +11,14 @@
 import optax
 import typer
 from fastavro import parse_schema, writer
+from serde import toml
 
 from emevo import Env
 from emevo import birth_and_death as bd
 from emevo import make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
-from emevo.exp_utils import Log
+from emevo.exp_utils import BDConfig, CfConfig, Log
 from emevo.rl.ppo_normal import (
     NormalPPONet,
     Rollout,
@@ -36,14 +37,8 @@ class LinearReward(eqx.Module):
     weight: jax.Array
     max_action_norm: float
 
-    def __init__(
-        self,
-        max_action_norm: float,
-        n_agents: int,
-        key: chex.PRNGKey,
-    ) -> None:
+    def __init__(self, key: chex.PRNGKey, n_agents: int) -> None:
         self.weight = jax.random.normal(key, (n_agents, 4))
-        self.max_action_norm = max_action_norm
 
     def __call__(self, collision: jax.Array, action: jax.Array) -> jax.Array:
         action_norm = jnp.sqrt(jnp.sum(action**2, axis=-1, keepdims=True))
@@ -199,6 +194,10 @@ def run_evolution(
     minibatch_size: int,
     n_rollout_steps: int,
     n_total_steps: int,
+    reward_fn: LinearReward,
+    hazard_fn: bd.HazardFunction,
+    birth_fn: bd.BirthFunction,
+    logdir: Path,
     debug_vis: bool = False,
 ) -> NormalPPONet:
     key, net_key, reset_key = jax.random.split(key, 3)
@@ -229,6 +228,9 @@ def run_evolution(
             obs,
             env,
             pponet,
+            reward_fn,
+            hazard_fn,
+            birth_fn,
             key,
             n_rollout_steps,
             gamma,
@@ -238,8 +240,6 @@ def run_evolution(
             minibatch_size,
             n_optim_epochs,
         )
-        ri = jnp.sum(jnp.squeeze(rewards_i, axis=-1), axis=0)
-        rewards = rewards + ri
         if visualizer is not None:
             visualizer.render(env_state)
             visualizer.show()
@@ -265,15 +265,30 @@ def evolve(
     minibatch_size: int = 128,
     n_rollout_steps: int = 1024,
     n_total_steps: int = 1024 * 1000,
-    cfconfig: Path = here.joinpath("../config/env/20231214-square.toml"),
-    bdconfig: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
+    cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
+    bdconfig_path: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
     reward_fn: Literal["linear", "sigmoid"] = "linear",
     logdir: Path = Path("./log"),
     debug_vis: bool = False,
 ) -> None:
-    env = make("CircleForaging-v0")
+    with cfconfig_path.open("r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+    with bdconfig_path.open("r") as f:
+        bdconfig = toml.from_toml(BDConfig, f.read())
+
+    # Override config
+    cfconfig.n_agents = n_agents
+    env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
+    birth_fn, hazard_fn = bdconfig.load_models()
+    key, reward_key = jax.random.split(jax.random.PRNGKey(seed))
+    if reward_fn == "linear":
+        reward_fn_instance = LinearReward(reward_key, cfconfig.n_max_agents)
+    elif reward_fn == "sigmoid":
+        assert False, "Unimplemented"
+    else:
+        raise ValueError(f"Invalid reward_fn {reward_fn}")
     network = run_evolution(
-        jax.random.PRNGKey(seed),
+        key,
         n_agents,
         env,
         optax.adam(adam_lr, eps=adam_eps),
@@ -283,6 +298,10 @@ def evolve(
         minibatch_size,
         n_rollout_steps,
         n_total_steps,
+        reward_fn_instance,
+        hazard_fn,
+        birth_fn,
+        logdir,
         debug_vis,
     )
     # eqx.tree_serialise_leaves(modelpath, network)
diff --git a/setup-venv b/setup-venv
new file mode 100755
index 00000000..fb489a17
--- /dev/null
+++ b/setup-venv
@@ -0,0 +1,15 @@
+#!/bin/bash
+set -eo pipefail
+
+if [[ -d .exp-venv ]]; then
+    exit 0
+fi
+
+mkdir .exp-venv
+python -m venv .exp-venv
+if [[ -f requirements/experiments.txt ]]; then
+    nox -s compile -- -k experiments
+fi
+source .venv/bin/activate
+pip install pip-tools
+pip-sync requirements/experiments.txt
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 19764a75..afe0c028 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -11,7 +11,6 @@
 import serde
 
 from emevo import birth_and_death as bd
-from emevo.env import Profile, Status
 
 
 @serde.serde

From 1614885b65dcc6b06ca3c03df6a64c9f96d71977 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 15 Dec 2023 17:21:39 +0900
Subject: [PATCH 122/337] Fix setup-venv

---
 setup-venv | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/setup-venv b/setup-venv
index fb489a17..5fca703d 100755
--- a/setup-venv
+++ b/setup-venv
@@ -1,15 +1,15 @@
 #!/bin/bash
 set -eo pipefail
 
-if [[ -d .exp-venv ]]; then
-    exit 0
+if [[ ! -d .exp-venv ]]; then
+    mkdir .exp-venv
+    python -m venv .exp-venv
 fi
 
-mkdir .exp-venv
-python -m venv .exp-venv
-if [[ -f requirements/experiments.txt ]]; then
+if [[ ! -f requirements/experiments.txt ]]; then
     nox -s compile -- -k experiments
 fi
-source .venv/bin/activate
+
+source .exp-venv/bin/activate
 pip install pip-tools
 pip-sync requirements/experiments.txt

From 6dc9a40aaf229558404d2243c3a1429ace5739d6 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 18 Dec 2023 14:40:12 +0900
Subject: [PATCH 123/337] test_config

---
 .gitignore                      |  4 ++-
 config/env/20231214-square.toml |  2 +-
 experiments/cf_asexual_evo.py   | 23 ++++++++++++-----
 src/emevo/exp_utils.py          | 44 ++++++++++++++++++++++-----------
 tests/test_config.py            | 10 ++++++++
 5 files changed, 61 insertions(+), 22 deletions(-)
 create mode 100644 tests/test_config.py

diff --git a/.gitignore b/.gitignore
index d3da7d66..0e00be34 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,7 +7,9 @@
 **/build/
 **/*.egg-info/
 **/.mypy_cache/
+.virtual_documents/
 .ipynb_checkpoints/
 requirements/*.txt
 # This should be local
-pyrightconfig.json
\ No newline at end of file
+pyrightconfig.json
+*.eqx
\ No newline at end of file
diff --git a/config/env/20231214-square.toml b/config/env/20231214-square.toml
index 12b31c5d..2f7cedad 100644
--- a/config/env/20231214-square.toml
+++ b/config/env/20231214-square.toml
@@ -22,7 +22,7 @@ max_force = 40.0
 min_force = -20.0
 init_energy = 20.0
 energy_capacity = 100.0
-force_energy_consumption = 0.01 / 40.0
+force_energy_consumption = 0.00025
 energy_share_ratio = 0.4
 n_velocity_iter = 6
 n_position_iter = 2
diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 1308ef2a..3a48a697 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -1,7 +1,8 @@
 """Example of using circle foraging environment"""
 import dataclasses
+import enum
 from pathlib import Path
-from typing import Literal
+from typing import Protocol
 
 import chex
 import equinox as eqx
@@ -11,6 +12,7 @@
 import optax
 import typer
 from fastavro import parse_schema, writer
+from jax._src.numpy.lax_numpy import Protocol
 from serde import toml
 
 from emevo import Env
@@ -33,6 +35,11 @@
 N_MAX_AGENTS: int = 10
 
 
+class RewardFn(Protocol):
+    def __call__(self, collision: jax.Array, action: jax.Array) -> jax.Array:
+        ...
+
+
 class LinearReward(eqx.Module):
     weight: jax.Array
     max_action_norm: float
@@ -46,6 +53,11 @@ def __call__(self, collision: jax.Array, action: jax.Array) -> jax.Array:
         return jax.vmap(jnp.dot)(input_, self.weight)
 
 
+class RewardKind(str, enum.Enum):
+    LINEAR = "linear"
+    SIGMOID = "sigmoid"
+
+
 def visualize(
     key: chex.PRNGKey,
     env: Env,
@@ -243,7 +255,6 @@ def run_evolution(
         if visualizer is not None:
             visualizer.render(env_state)
             visualizer.show()
-            print(f"Rewards: {[x.item() for x in ri[: n_agents]]}")
         # weight_summary(pponet)
     print(f"Sum of rewards {[x.item() for x in rewards[: n_agents]]}")
     return pponet
@@ -267,7 +278,7 @@ def evolve(
     n_total_steps: int = 1024 * 1000,
     cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
     bdconfig_path: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
-    reward_fn: Literal["linear", "sigmoid"] = "linear",
+    reward_fn: RewardKind = RewardKind.LINEAR,
     logdir: Path = Path("./log"),
     debug_vis: bool = False,
 ) -> None:
@@ -277,13 +288,13 @@ def evolve(
         bdconfig = toml.from_toml(BDConfig, f.read())
 
     # Override config
-    cfconfig.n_agents = n_agents
+    cfconfig.n_initial_agents = n_agents
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
     birth_fn, hazard_fn = bdconfig.load_models()
     key, reward_key = jax.random.split(jax.random.PRNGKey(seed))
-    if reward_fn == "linear":
+    if reward_fn == RewardKind.LINEAR:
         reward_fn_instance = LinearReward(reward_key, cfconfig.n_max_agents)
-    elif reward_fn == "sigmoid":
+    elif reward_fn == RewardKind.SIGMOID:
         assert False, "Unimplemented"
     else:
         raise ValueError(f"Invalid reward_fn {reward_fn}")
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index afe0c028..670a0d9e 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -3,35 +3,51 @@
 
 import dataclasses
 import importlib
-from typing import Dict, List, Tuple, Type
+from typing import Dict, Tuple, Type, Union
 
 import chex
-import fastavro
 import jax
 import serde
 
 from emevo import birth_and_death as bd
+from emevo.environments.circle_foraging import SensorRange
 
 
 @serde.serde
 @dataclasses.dataclass
 class CfConfig:
-    agent_radius: float
-    n_agents: int
-    n_agent_sensors: int
-    sensor_length: float
-    food_loc_fn: str
-    food_num_fn: Tuple[str, int]
-    xlim: Tuple[float, float]
-    ylim: Tuple[float, float]
-    env_radius: float
-    env_shape: str
-    obstacles: List[Tuple[float, float, float, float]]
-    seed: int
+    n_initial_agents: int = 6
+    n_max_agents: int = 100
+    n_max_foods: int = 40
+    food_num_fn: Union[str, Tuple[str, ...]] = "constant"
+    food_loc_fn: Union[str, Tuple[str, ...]] = "gaussian"
+    agent_loc_fn: Union[str, Tuple[str, ...]] = "uniform"
+    xlim: Tuple[float, float] = (0.0, 200.0)
+    ylim: Tuple[float, float] = (0.0, 200.0)
+    env_radius: float = 120.0
+    env_shape: str = "square"
+    obstacles: str = "none"
+    newborn_loc: str = "neighbor"
+    neighbor_stddev: float = 40.0
+    n_agent_sensors: int = 16
+    sensor_length: float = 100.0
+    sensor_range: SensorRange = SensorRange.WIDE
+    agent_radius: float = 10.0
+    food_radius: float = 4.0
+    foodloc_interval: int = 1000
+    dt: float = 0.1
     linear_damping: float = 0.8
     angular_damping: float = 0.6
     max_force: float = 40.0
     min_force: float = -20.0
+    init_energy: float = 20.0
+    energy_capacity: float = 100.0
+    force_energy_consumption: float = 0.01 / 40.0
+    energy_share_ratio: float = 0.4
+    n_velocity_iter: int = 6
+    n_position_iter: int = 2
+    n_physics_iter: int = 5
+    max_place_attempts: int = 10
 
 
 def _load_cls(cls_path: str) -> Type:
diff --git a/tests/test_config.py b/tests/test_config.py
new file mode 100644
index 00000000..d9654d98
--- /dev/null
+++ b/tests/test_config.py
@@ -0,0 +1,10 @@
+from serde import toml
+
+from emevo.exp_utils import CfConfig
+
+
+def test_cfconfig() -> None:
+    with open("config/env/20231214-square.toml", "r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+
+    assert cfconfig.sensor_range == "wide"

From 11138805386f6ca00fe67a0b8507e0c126874a00 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 18 Dec 2023 18:14:57 +0900
Subject: [PATCH 124/337] Move position masking to moderngl_vis

---
 config/env/20231214-square.toml           |  4 ++--
 experiments/cf_asexual_evo.py             | 15 +++++---------
 src/emevo/birth_and_death.py              | 12 ++++++------
 src/emevo/env.py                          |  1 +
 src/emevo/environments/circle_foraging.py | 24 +++++++++++------------
 src/emevo/environments/moderngl_vis.py    | 23 ++++++++++++++++++----
 tests/test_config.py                      | 12 +++++++++++-
 7 files changed, 56 insertions(+), 35 deletions(-)

diff --git a/config/env/20231214-square.toml b/config/env/20231214-square.toml
index 2f7cedad..e4118638 100644
--- a/config/env/20231214-square.toml
+++ b/config/env/20231214-square.toml
@@ -1,7 +1,7 @@
 n_initial_agents = 20
 n_max_agents = 100
-n_max_foods = 20
-food_num_fn = ["logistic", 0.01, 20]
+n_max_foods = 40
+food_num_fn = ["logistic", 20, 0.01, 40]
 food_loc_fn = "gaussian"
 agent_loc_fn = "uniform"
 xlim = [0.0, 360.0]
diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 3a48a697..9251ac36 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -32,8 +32,6 @@
 )
 from emevo.visualizer import SaveVideoWrapper
 
-N_MAX_AGENTS: int = 10
-
 
 class RewardFn(Protocol):
     def __call__(self, collision: jax.Array, action: jax.Array) -> jax.Array:
@@ -42,7 +40,6 @@ def __call__(self, collision: jax.Array, action: jax.Array) -> jax.Array:
 
 class LinearReward(eqx.Module):
     weight: jax.Array
-    max_action_norm: float
 
     def __init__(self, key: chex.PRNGKey, n_agents: int) -> None:
         self.weight = jax.random.normal(key, (n_agents, 4))
@@ -126,7 +123,7 @@ def step_rollout(
         state_t1d = env.deactivate(state_t1, dead)
         birth_prob = birth_fn(state_t1d.status.age, state_t1d.status.energy)
         possible_parents = jnp.logical_and(
-            jnp.logical_not(dead),
+            jnp.logical_and(jnp.logical_not(dead), state.profile.is_active()),
             jax.random.bernoulli(birth_key, p=birth_prob),
         )
         state_t1db, parents = env.activate(state_t1d, possible_parents)
@@ -168,7 +165,7 @@ def epoch(
     minibatch_size: int,
     n_optim_epochs: int,
 ) -> tuple[State, Obs, Log, optax.OptState, NormalPPONet]:
-    keys = jax.random.split(prng_key, N_MAX_AGENTS + 1)
+    keys = jax.random.split(prng_key, env.n_max_agents + 1)
     env_state, rollout, log, obs, next_value = exec_rollout(
         state,
         initial_obs,
@@ -197,7 +194,6 @@ def epoch(
 
 def run_evolution(
     key: jax.Array,
-    n_agents: int,
     env: Env,
     adam: optax.GradientTransformation,
     gamma: float,
@@ -220,7 +216,7 @@ def run_evolution(
         input_size,
         64,
         act_size,
-        jax.random.split(net_key, N_MAX_AGENTS),
+        jax.random.split(net_key, env.n_max_agents),
     )
     adam_init, adam_update = adam
     opt_state = jax.vmap(adam_init)(eqx.filter(pponet, eqx.is_array))
@@ -228,7 +224,7 @@ def run_evolution(
     obs = timestep.obs
 
     n_loop = n_total_steps // n_rollout_steps
-    rewards = jnp.zeros(N_MAX_AGENTS)
+    rewards = jnp.zeros(env.n_max_agents)
     keys = jax.random.split(key, n_loop)
     if debug_vis:
         visualizer = env.visualizer(env_state, figsize=(640.0, 640.0))
@@ -261,7 +257,7 @@ def run_evolution(
 
 
 app = typer.Typer(pretty_exceptions_show_locals=False)
-here = Path(__file__)
+here = Path(__file__).parent
 
 
 @app.command()
@@ -300,7 +296,6 @@ def evolve(
         raise ValueError(f"Invalid reward_fn {reward_fn}")
     network = run_evolution(
         key,
-        n_agents,
         env,
         optax.adam(adam_lr, eps=adam_eps),
         gamma,
diff --git a/src/emevo/birth_and_death.py b/src/emevo/birth_and_death.py
index f73b36dc..2ba11197 100644
--- a/src/emevo/birth_and_death.py
+++ b/src/emevo/birth_and_death.py
@@ -22,7 +22,7 @@ def survival(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         return jnp.exp(-self.cumulative(age, energy))
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(frozen=True)
 class DeterministicHazard(HazardFunction):
     """
     A deterministic hazard function where an agent dies when
@@ -52,7 +52,7 @@ def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         )
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(frozen=True)
 class ConstantHazard(HazardFunction):
     """
     Hazard with constant death rate.
@@ -79,7 +79,7 @@ def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         return self(age, energy) * age
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(frozen=True)
 class EnergyLogisticHazard(HazardFunction):
     """
     Hazard with death rate that only depends on energy.
@@ -101,7 +101,7 @@ def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         return self._energy_death_rate(energy) * age
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(frozen=True)
 class GompertzHazard(ConstantHazard):
     """
     Hazard with exponentially increasing death rate.
@@ -123,7 +123,7 @@ def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         return ht - h0
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(frozen=True)
 class ELGompertzHazard(EnergyLogisticHazard):
     """
     Exponentially increasing with time + EnergyLogistic
@@ -158,7 +158,7 @@ def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         ...
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(frozen=True)
 class EnergyLogisticBirth(BirthFunction):
     """
     Only energy is important to give birth.
diff --git a/src/emevo/env.py b/src/emevo/env.py
index 102486c5..96e44036 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -130,6 +130,7 @@ class Env(abc.ABC, Generic[STATE, OBS]):
 
     act_space: Space
     obs_space: Space
+    n_max_agents: int
 
     def __init__(self, *args, **kwargs) -> None:
         # To supress PyRight errors in registry
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index e8b32b72..08b6ad01 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -59,7 +59,7 @@
 MAX_VELOCITY: float = 10.0
 AGENT_COLOR: Color = Color(2, 204, 254)
 FOOD_COLOR: Color = Color(254, 2, 162)
-NOWHERE: float = -100.0
+NOWHERE: float = 0.0
 N_OBJECTS: int = 3
 
 
@@ -368,7 +368,7 @@ def __init__(
         assert n_max_agents > n_initial_agents
         assert n_max_foods > self._food_num_fn.initial
         self._n_initial_agents = n_initial_agents
-        self._n_max_agents = n_max_agents
+        self.n_max_agents = n_max_agents
         self._n_initial_foods = self._food_num_fn.initial
         self._n_max_foods = n_max_foods
         self._max_place_attempts = max_place_attempts
@@ -407,11 +407,10 @@ def __init__(
         # Obs
         self._n_sensors = n_agent_sensors
         # Some cached constants
-        self._invisible_xy = jnp.ones(2) * NOWHERE
         act_p1 = Vec2d(0, agent_radius).rotated(np.pi * 0.75)
         act_p2 = Vec2d(0, agent_radius).rotated(-np.pi * 0.75)
-        self._act_p1 = jnp.tile(jnp.array(act_p1), (self._n_max_agents, 1))
-        self._act_p2 = jnp.tile(jnp.array(act_p2), (self._n_max_agents, 1))
+        self._act_p1 = jnp.tile(jnp.array(act_p1), (self.n_max_agents, 1))
+        self._act_p2 = jnp.tile(jnp.array(act_p2), (self.n_max_agents, 1))
         self._init_agent = jax.jit(
             functools.partial(
                 place,
@@ -653,7 +652,7 @@ def activate(
         is_parent: jax.Array,
     ) -> tuple[CFState, jax.Array]:
         circle = state.physics.circle
-        keys = jax.random.split(state.key, self._n_max_agents + 1)
+        keys = jax.random.split(state.key, self.n_max_agents + 1)
         new_xy, ok = self._place_newborn(
             state.agent_loc,
             state.physics,
@@ -695,12 +694,13 @@ def activate(
         return new_state, parents_id
 
     def deactivate(self, state: CFState, flag: jax.Array) -> CFState:
-        p_xy = state.physics.circle.p.xy.at[flag].set(self._invisible_xy)
+        expanded_flag = jnp.expand_dims(flag, axis=1)
+        p_xy = jnp.where(expanded_flag, NOWHERE, state.physics.circle.p.xy)
         p = replace(state.physics.circle.p, xy=p_xy)
-        v_xy = state.physics.circle.v.xy.at[flag].set(0.0)
-        v_angle = state.physics.circle.v.angle.at[flag].set(0.0)
+        v_xy = jnp.where(expanded_flag, 0.0, state.physics.circle.v.xy)
+        v_angle = jnp.where(flag, 0.0, state.physics.circle.v.angle)
         v = Velocity(angle=v_angle, xy=v_xy)
-        is_active = state.physics.circle.is_active.at[flag].set(False)
+        is_active = jnp.where(flag, False, state.physics.circle.is_active)
         circle = replace(state.physics.circle, p=p, v=v, is_active=is_active)
         physics = replace(state.physics, circle=circle)
         profile = state.profile.deactivate(flag)
@@ -709,7 +709,7 @@ def deactivate(self, state: CFState, flag: jax.Array) -> CFState:
 
     def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
         physics, agent_loc, food_loc = self._initialize_physics_state(key)
-        nmax = self._n_max_agents
+        nmax = self.n_max_agents
         profile = init_profile(self._n_initial_agents, nmax)
         status = init_status(self._n_initial_agents, nmax, self._init_energy)
         state = CFState(
@@ -748,7 +748,7 @@ def _initialize_physics_state(
         is_active_c = jnp.concatenate(
             (
                 jnp.ones(self._n_initial_agents, dtype=bool),
-                jnp.zeros(self._n_max_agents - self._n_initial_agents, dtype=bool),
+                jnp.zeros(self.n_max_agents - self._n_initial_agents, dtype=bool),
             )
         )
         is_active_s = jnp.concatenate(
diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index 9822587a..4da6e885 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -20,6 +20,9 @@ class HasStateD(Protocol):
     stated: StateDict
 
 
+NOWHERE: float = -1000.0
+
+
 _CIRCLE_VERTEX_SHADER = """
 #version 330
 uniform mat4 proj;
@@ -259,7 +262,8 @@ def _collect_circles(
     state: State,
     circle_scaling: float,
 ) -> tuple[NDArray, NDArray, NDArray]:
-    points = np.array(state.p.xy, dtype=np.float32)
+    flag = np.array(state.is_active).reshape(-1, 1)
+    points = np.where(flag, np.array(state.p.xy, dtype=np.float32), NOWHERE)
     scales = circle.radius * circle_scaling
     colors = np.array(circle.rgba, dtype=np.float32) / 255.0
     is_active = np.expand_dims(np.array(state.is_active), axis=1)
@@ -271,7 +275,8 @@ def _collect_static_lines(segment: Segment, state: State) -> NDArray:
     a, b = segment.point1, segment.point2
     a = state.p.transform(a)
     b = state.p.transform(b)
-    return np.concatenate((a, b), axis=1).reshape(-1, 2)
+    flag = np.repeat(np.array(state.is_active), 2).reshape(-1, 1)
+    return np.where(flag, np.concatenate((a, b), axis=1).reshape(-1, 2), NOWHERE)
 
 
 def _collect_heads(circle: Circle, state: State) -> NDArray:
@@ -279,7 +284,8 @@ def _collect_heads(circle: Circle, state: State) -> NDArray:
     x = jnp.zeros_like(y)
     p1, p2 = jnp.stack((x, y * 0.8), axis=1), jnp.stack((x, y * 1.2), axis=1)
     p1, p2 = state.p.transform(p1), state.p.transform(p2)
-    return np.concatenate((p1, p2), axis=1).reshape(-1, 2)
+    flag = np.repeat(np.array(state.is_active), 2).reshape(-1, 1)
+    return np.where(flag, np.concatenate((p1, p2), axis=1).reshape(-1, 2), NOWHERE)
 
 
 # def _collect_policies(
@@ -406,7 +412,16 @@ def collect_sensors(stated: StateDict) -> NDArray:
                     sensor_fn(stated=stated),  # type: ignore
                     axis=1,
                 )
-                return sensors.reshape(-1, 2).astype(jnp.float32)
+                sensors = sensors.reshape(-1, 2).astype(jnp.float32)
+                flag = np.repeat(
+                    np.array(stated.circle.is_active),
+                    sensors.shape[0] // stated.circle.batch_size(),
+                )
+                return np.where(
+                    flag.reshape(-1, 1),
+                    sensors,
+                    NOWHERE,
+                )
 
             self._sensors = SegmentVA(
                 ctx=context,
diff --git a/tests/test_config.py b/tests/test_config.py
index d9654d98..53baea19 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -1,6 +1,16 @@
 from serde import toml
 
-from emevo.exp_utils import CfConfig
+from emevo import birth_and_death as bd
+from emevo.exp_utils import BDConfig, CfConfig
+
+
+def test_bdconfig() -> None:
+    with open("config/bd/20230530-a035-e020.toml", "r") as f:
+        bdconfig = toml.from_toml(BDConfig, f.read())
+
+    birth_fn, hazard_fn = bdconfig.load_models()
+    assert isinstance(birth_fn, bd.EnergyLogisticBirth)
+    assert isinstance(hazard_fn, bd.ELGompertzHazard)
 
 
 def test_cfconfig() -> None:

From aa52e16808c6848284c0628a7de582b12ad40d28 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 19 Dec 2023 01:39:50 +0900
Subject: [PATCH 125/337] Make activate jittable

---
 smoke-tests/circle_loop.py                |  6 ++-
 src/emevo/environments/circle_foraging.py | 56 ++++++++++++++++-------
 2 files changed, 43 insertions(+), 19 deletions(-)

diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index 82bb0d30..ed12a784 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -76,6 +76,8 @@ def main(
     replace_interval = steps // 10
     deactivate_index = n_agents - 1
     activate_p = jnp.zeros(n_max_agents).at[jnp.arange(5)].set(0.5)
+    deactivate = jax.jit(env.deactivate)
+    activate = jax.jit(env.activate)
     for i in tqdm(range(steps)):
         before = datetime.datetime.now()
         state, _ = jit_step(state, jit_sample(keys[i + 1]))
@@ -90,11 +92,11 @@ def main(
                 flag = (
                     jnp.zeros(n_max_agents, dtype=bool).at[deactivate_index].set(True)
                 )
-                state = env.deactivate(state, flag)
+                state = deactivate(state, flag)
                 deactivate_index -= 1
             else:
                 flag = jax.random.bernoulli(keys[i + 1], p=activate_p)
-                state, parents = env.activate(state, flag)
+                state, parents = activate(state, flag)
                 print("Parents: ", parents)
 
         if visualizer is not None:
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 08b6ad01..9c3b0d2d 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -299,6 +299,12 @@ def _first_n_true(boolean_array: jax.Array, n: jax.Array) -> jax.Array:
     return jnp.logical_and(boolean_array, jnp.cumsum(boolean_array) <= n)
 
 
+def _nonzero(arr: jax.Array, n: int) -> jax.Array:
+    cums = jnp.cumsum(arr)
+    bincount = jnp.zeros(n, dtype=jnp.int32).at[cums].add(1)
+    return jnp.cumsum(bincount)
+
+
 class CircleForaging(Env):
     def __init__(
         self,
@@ -651,47 +657,63 @@ def activate(
         state: CFState,
         is_parent: jax.Array,
     ) -> tuple[CFState, jax.Array]:
+        N = self.n_max_agents
         circle = state.physics.circle
-        keys = jax.random.split(state.key, self.n_max_agents + 1)
+        keys = jax.random.split(state.key, N + 1)
         new_xy, ok = self._place_newborn(
             state.agent_loc,
             state.physics,
             keys[1:],
             circle.p.xy,
         )
-        possible_parents = jnp.logical_and(is_parent, ok)
-        slots = _first_n_true(
+        is_possible_parent = jnp.logical_and(is_parent, ok)
+        is_replaced = _first_n_true(
             jnp.logical_not(circle.is_active),
-            jnp.sum(possible_parents),
-        )
-        parents = _first_n_true(possible_parents, jnp.sum(slots))
-        xy = circle.p.xy.at[slots].set(new_xy[parents])
-        angle = jnp.where(slots, 0.0, circle.p.angle)
+            jnp.sum(is_possible_parent),
+        )
+        is_parent = _first_n_true(is_possible_parent, jnp.sum(is_replaced))
+        # parent_indices := nonzero_indices(parents) + (N, N, N, ....)
+        parent_indices = _nonzero(is_parent, N)
+        # empty_indices := nonzero_indices(not(is_active)) + (0, 0, 0, ....)
+        replaced_indices = _nonzero(is_replaced, N) % (N + 1)
+        # To use .at[].add, append (0, 0) to sampled xy
+        new_xy_with_sentinel = jnp.concatenate((new_xy, jnp.zeros((1, 2))))
+        xy = circle.p.xy.at[replaced_indices].add(new_xy_with_sentinel[parent_indices])
+        angle = jnp.where(is_replaced, 0.0, circle.p.angle)
         p = Position(angle=angle, xy=xy)
-        is_active = jnp.logical_or(slots, circle.is_active)
+        is_active = jnp.logical_or(is_replaced, circle.is_active)
         physics = replace(
             state.physics,
             circle=replace(circle, p=p, is_active=is_active),
         )
-        profile = state.profile.activate(slots, state.step)
+        profile = state.profile.activate(is_replaced, state.step)
         shared_energy = state.status.energy * self._energy_share_ratio
+        shared_energy_with_sentinel = jnp.concatenate((shared_energy, jnp.zeros(1)))
         init_energy = (
-            jnp.zeros_like(state.status.energy).at[slots].set(shared_energy[parents])
+            jnp.zeros_like(state.status.energy)
+            .at[replaced_indices]
+            .add(shared_energy_with_sentinel[parent_indices % N])
         )
-        status = state.status.activate(slots, init_energy=init_energy)
-        status = status.update(energy_delta=(status.energy - shared_energy) * parents)
+        status = state.status.activate(replaced_indices, init_energy=init_energy)
+        status = status.update(energy_delta=(status.energy - shared_energy) * is_parent)
+        n_children = jnp.sum(is_parent)
         new_state = replace(
             state,
             physics=physics,
             profile=profile,
             status=status,
-            agent_loc=state.agent_loc.increment(jnp.sum(slots)),
-            n_born_agents=state.n_born_agents + jnp.sum(slots),
+            agent_loc=state.agent_loc.increment(n_children),
+            n_born_agents=state.n_born_agents + n_children,
             key=keys[0],
         )
         empty_id = jnp.ones_like(state.profile.unique_id) * -1
-        parents_id = empty_id.at[slots].set(state.profile.unique_id[parents])
-        return new_state, parents_id
+        unique_id_with_sentinel = jnp.concatenate(
+            (state.profile.unique_id, jnp.zeros(1, dtype=jnp.int32))
+        )
+        parent_id = empty_id.at[replaced_indices].set(
+            unique_id_with_sentinel[parent_indices]
+        )
+        return new_state, parent_id
 
     def deactivate(self, state: CFState, flag: jax.Array) -> CFState:
         expanded_flag = jnp.expand_dims(flag, axis=1)

From 87dc5403288f59881febf5875e169a4e354f6d50 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 19 Dec 2023 15:28:10 +0900
Subject: [PATCH 126/337] Various bag fixes for experiments

---
 experiments/cf_asexual_evo.py             | 29 ++++++++++++++++-------
 src/emevo/env.py                          |  3 +--
 src/emevo/environments/circle_foraging.py | 14 +++++------
 src/emevo/exp_utils.py                    |  2 ++
 tests/test_status.py                      |  2 +-
 5 files changed, 32 insertions(+), 18 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 9251ac36..75c89b23 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -107,7 +107,7 @@ def step_rollout(
         net_out = vmap_apply(network, obs_t_array)
         actions = net_out.policy().sample(seed=act_key)
         state_t1, timestep = env.step(state_t, env.act_space.sigmoid_scale(actions))
-        rewards = reward_fn(obs_t.collision, actions)  # type: ignore
+        rewards = reward_fn(obs_t.collision, actions).reshape(-1, 1)
         rollout = Rollout(
             observations=obs_t_array,
             actions=actions,
@@ -128,6 +128,7 @@ def step_rollout(
         )
         state_t1db, parents = env.activate(state_t1d, possible_parents)
         log = Log(
+            dead=jnp.where(dead, state_t1.profile.unique_id, -1),  # type: ignore
             parents=parents,
             rewards=rewards,
             age=state_t1db.status.age,
@@ -206,6 +207,8 @@ def run_evolution(
     hazard_fn: bd.HazardFunction,
     birth_fn: bd.BirthFunction,
     logdir: Path,
+    xmax: float,
+    ymax: float,
     debug_vis: bool = False,
 ) -> NormalPPONet:
     key, net_key, reset_key = jax.random.split(key, 3)
@@ -224,14 +227,14 @@ def run_evolution(
     obs = timestep.obs
 
     n_loop = n_total_steps // n_rollout_steps
-    rewards = jnp.zeros(env.n_max_agents)
     keys = jax.random.split(key, n_loop)
     if debug_vis:
-        visualizer = env.visualizer(env_state, figsize=(640.0, 640.0))
+        visualizer = env.visualizer(env_state, figsize=(xmax * 2, ymax * 2))
     else:
         visualizer = None
+
     for i, key in enumerate(keys):
-        env_state, obs, rewards_i, opt_state, pponet = epoch(
+        env_state, obs, log, opt_state, pponet = epoch(
             env_state,
             obs,
             env,
@@ -251,8 +254,16 @@ def run_evolution(
         if visualizer is not None:
             visualizer.render(env_state)
             visualizer.show()
-        # weight_summary(pponet)
-    print(f"Sum of rewards {[x.item() for x in rewards[: n_agents]]}")
+
+        for dead, energy in zip(log.dead, log.energy):
+            if jnp.any(dead != -1):
+                print("Dead: ", dead[dead != -1])
+                print("Energy: ", energy[dead != -1])
+
+        for parental_log in log.parents:
+            if jnp.any(parental_log != -1):
+                for child in jnp.nonzero(parental_log)[0]:
+                    print(f"Child {child} Parent {parental_log[child]}")
     return pponet
 
 
@@ -263,7 +274,7 @@ def run_evolution(
 @app.command()
 def evolve(
     seed: int = 1,
-    n_agents: int = 2,
+    n_agents: int = 20,
     adam_lr: float = 3e-4,
     adam_eps: float = 1e-7,
     gamma: float = 0.999,
@@ -271,7 +282,7 @@ def evolve(
     n_optim_epochs: int = 10,
     minibatch_size: int = 128,
     n_rollout_steps: int = 1024,
-    n_total_steps: int = 1024 * 1000,
+    n_total_steps: int = 1024 * 10000,
     cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
     bdconfig_path: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
     reward_fn: RewardKind = RewardKind.LINEAR,
@@ -308,6 +319,8 @@ def evolve(
         hazard_fn,
         birth_fn,
         logdir,
+        cfconfig.xlim[1],
+        cfconfig.ylim[1],
         debug_vis,
     )
     # eqx.tree_serialise_leaves(modelpath, network)
diff --git a/src/emevo/env.py b/src/emevo/env.py
index 96e44036..fc3fa5f7 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -42,8 +42,7 @@ def update(self, energy_delta: jax.Array, capacity: float | None = 100.0) -> Sel
         return replace(self, energy=jnp.clip(energy, a_min=0.0, a_max=capacity))
 
 
-def init_status(n: int, max_n: int, init_energy: float) -> Status:
-    assert max_n >= n
+def init_status(max_n: int, init_energy: float) -> Status:
     return Status(
         age=jnp.zeros(max_n, dtype=jnp.int32),
         energy=jnp.ones(max_n, dtype=jnp.float32) * init_energy,
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 9c3b0d2d..6c6df608 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -692,9 +692,9 @@ def activate(
         init_energy = (
             jnp.zeros_like(state.status.energy)
             .at[replaced_indices]
-            .add(shared_energy_with_sentinel[parent_indices % N])
+            .add(shared_energy_with_sentinel[parent_indices])
         )
-        status = state.status.activate(replaced_indices, init_energy=init_energy)
+        status = state.status.activate(is_replaced, init_energy=init_energy)
         status = status.update(energy_delta=(status.energy - shared_energy) * is_parent)
         n_children = jnp.sum(is_parent)
         new_state = replace(
@@ -731,9 +731,9 @@ def deactivate(self, state: CFState, flag: jax.Array) -> CFState:
 
     def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
         physics, agent_loc, food_loc = self._initialize_physics_state(key)
-        nmax = self.n_max_agents
-        profile = init_profile(self._n_initial_agents, nmax)
-        status = init_status(self._n_initial_agents, nmax, self._init_energy)
+        N = self.n_max_agents
+        profile = init_profile(self._n_initial_agents, N)
+        status = init_status(N, self._init_energy)
         state = CFState(
             physics=physics,
             solver=self._physics.init_solver(),
@@ -749,13 +749,13 @@ def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
         sensor_obs = self._sensor_obs(stated=physics)
         obs = CFObs(
             sensor=sensor_obs.reshape(-1, self._n_sensors, N_OBJECTS),
-            collision=jnp.zeros((nmax, N_OBJECTS), dtype=bool),
+            collision=jnp.zeros((N, N_OBJECTS), dtype=bool),
             angle=physics.circle.p.angle,
             velocity=physics.circle.v.xy,
             angular_velocity=physics.circle.v.angle,
         )
         # They shouldn't encount now
-        timestep = TimeStep(encount=jnp.zeros((nmax, nmax), dtype=bool), obs=obs)
+        timestep = TimeStep(encount=jnp.zeros((N, N), dtype=bool), obs=obs)
         return state, timestep
 
     def _initialize_physics_state(
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 670a0d9e..c7f1a7a6 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -76,6 +76,7 @@ def load_models(self) -> tuple[bd.BirthFunction, bd.HazardFunction]:
 class Log:
     parents: jax.Array
     rewards: jax.Array
+    dead: jax.Array
     age: jax.Array
     energy: jax.Array
     birthtime: jax.Array
@@ -97,6 +98,7 @@ def array(dtype: str) -> dict[str, str]:
             "fields": [
                 {"name": "parents", "type": array("int")},
                 {"name": "rewards", "type": array("float")},
+                {"name": "dead", "type": array("int")},
                 {"name": "energy", "type": array("float")},
                 {"name": "age", "type": array("int")},
                 {"name": "birthtime", "type": array("int")},
diff --git a/tests/test_status.py b/tests/test_status.py
index de1e23c1..7f0963a5 100644
--- a/tests/test_status.py
+++ b/tests/test_status.py
@@ -9,7 +9,7 @@
     [(1, 10.0), (1, 100.0), (10, 10.0), (10, 100.0)],
 )
 def test_status_clipping(n: int, capacity: float) -> None:
-    status = init_status(n=n, max_n=n, init_energy=0.0)
+    status = init_status(max_n=n, init_energy=0.0)
     for _ in range(200):
         status.update(energy_delta=jnp.ones(n), capacity=capacity)
         assert jnp.all(status.energy >= 0.0)

From ccc17e4bd32450e17b67b07ad13928a0246e8d68 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 19 Dec 2023 18:13:47 +0900
Subject: [PATCH 127/337] Try parquet

---
 .gitignore                    |  4 ++-
 experiments/cf_asexual_evo.py | 55 ++++++++++++++++++++++++++++-------
 requirements/experiments.in   |  2 +-
 src/emevo/exp_utils.py        | 31 ++++----------------
 4 files changed, 54 insertions(+), 38 deletions(-)

diff --git a/.gitignore b/.gitignore
index 0e00be34..c858b045 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,4 +12,6 @@
 requirements/*.txt
 # This should be local
 pyrightconfig.json
-*.eqx
\ No newline at end of file
+*.eqx
+# Default log dir
+log/
\ No newline at end of file
diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 75c89b23..a26789bc 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -10,8 +10,9 @@
 import jax.numpy as jnp
 import numpy as np
 import optax
+import pyarrow as pa
+import pyarrow.parquet as pq
 import typer
-from fastavro import parse_schema, writer
 from jax._src.numpy.lax_numpy import Protocol
 from serde import toml
 
@@ -20,7 +21,7 @@
 from emevo import make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
-from emevo.exp_utils import BDConfig, CfConfig, Log
+from emevo.exp_utils import BDConfig, CfConfig, Log, tree_as_list
 from emevo.rl.ppo_normal import (
     NormalPPONet,
     Rollout,
@@ -50,6 +51,10 @@ def __call__(self, collision: jax.Array, action: jax.Array) -> jax.Array:
         return jax.vmap(jnp.dot)(input_, self.weight)
 
 
+def evolve_rewards(old, method, parents: jax.Array):
+    pass
+
+
 class RewardKind(str, enum.Enum):
     LINEAR = "linear"
     SIGMOID = "sigmoid"
@@ -130,7 +135,7 @@ def step_rollout(
         log = Log(
             dead=jnp.where(dead, state_t1.profile.unique_id, -1),  # type: ignore
             parents=parents,
-            rewards=rewards,
+            rewards=rewards.ravel(),
             age=state_t1db.status.age,
             energy=state_t1db.status.energy,
             birthtime=state_t1db.profile.birthtime,
@@ -207,6 +212,7 @@ def run_evolution(
     hazard_fn: bd.HazardFunction,
     birth_fn: bd.BirthFunction,
     logdir: Path,
+    log_interval: int,
     xmax: float,
     ymax: float,
     debug_vis: bool = False,
@@ -233,6 +239,24 @@ def run_evolution(
     else:
         visualizer = None
 
+    log_list = []
+
+    def write_log(index: int) -> None:
+        log = jax.tree_map(
+            lambda *args: np.array(jnp.concatenate(args, axis=0)),
+            *log_list,
+        )
+        print(log)
+        log_dict = dataclasses.asdict(log)
+        print({arr.shape for arr in log_dict.values()})
+        table = pa.Table.from_pydict(log_dict)
+        pq.write_table(
+            table,
+            logdir.joinpath(f"log-{index}.parquet"),
+            compression="zstd",
+        )
+        log_list.clear()
+
     for i, key in enumerate(keys):
         env_state, obs, log, opt_state, pponet = epoch(
             env_state,
@@ -255,15 +279,22 @@ def run_evolution(
             visualizer.render(env_state)
             visualizer.show()
 
-        for dead, energy in zip(log.dead, log.energy):
-            if jnp.any(dead != -1):
-                print("Dead: ", dead[dead != -1])
-                print("Energy: ", energy[dead != -1])
+        # Extinct?
+        n_active = jnp.sum(env_state.profile.is_active())
+        if n_active == 0:
+            print(f"Extinct after {i + 1} epochs")
+            return pponet
+
+        import datetime as dt
+
+        log_list.append(log)
+        if (i + 1) % log_interval == 0:
+            index = (i + 1) // log_interval
+            print("Start parquet writing")
+            now = dt.datetime.now()
+            write_log(index)
 
-        for parental_log in log.parents:
-            if jnp.any(parental_log != -1):
-                for child in jnp.nonzero(parental_log)[0]:
-                    print(f"Child {child} Parent {parental_log[child]}")
+            print(f"End parquet writing: {(dt.datetime.now() - now).seconds} sec")
     return pponet
 
 
@@ -287,6 +318,7 @@ def evolve(
     bdconfig_path: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
     reward_fn: RewardKind = RewardKind.LINEAR,
     logdir: Path = Path("./log"),
+    log_interval: int = 5,
     debug_vis: bool = False,
 ) -> None:
     with cfconfig_path.open("r") as f:
@@ -319,6 +351,7 @@ def evolve(
         hazard_fn,
         birth_fn,
         logdir,
+        log_interval,
         cfconfig.xlim[1],
         cfconfig.ylim[1],
         debug_vis,
diff --git a/requirements/experiments.in b/requirements/experiments.in
index 7bc2621b..13a50047 100644
--- a/requirements/experiments.in
+++ b/requirements/experiments.in
@@ -1,4 +1,4 @@
 -e .[video,pyside6]
-fastavro
+pyarrow
 tqdm
 typer
\ No newline at end of file
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index c7f1a7a6..be955779 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -3,7 +3,7 @@
 
 import dataclasses
 import importlib
-from typing import Dict, Tuple, Type, Union
+from typing import Any, Dict, Tuple, Type, Union
 
 import chex
 import jax
@@ -13,6 +13,11 @@
 from emevo.environments.circle_foraging import SensorRange
 
 
+def tree_as_list(pytree: Any) -> list[Any]:
+    leaves, treedef = jax.tree_util.tree_flatten(pytree)
+    return [treedef.unflatten(leaf) for leaf in zip(*leaves)]  # type: ignore
+
+
 @serde.serde
 @dataclasses.dataclass
 class CfConfig:
@@ -82,27 +87,3 @@ class Log:
     birthtime: jax.Array
     generation: jax.Array
     unique_id: jax.Array
-
-    @staticmethod
-    def avro_schema() -> dict:
-        """Apache avro schema for this class"""
-
-        def array(dtype: str) -> dict[str, str]:
-            return {"type": "array", "items": dtype}
-
-        return {
-            "doc": "Default log schema for emevo",
-            "name": "Log",
-            "namespace": "emevo",
-            "type": "record",
-            "fields": [
-                {"name": "parents", "type": array("int")},
-                {"name": "rewards", "type": array("float")},
-                {"name": "dead", "type": array("int")},
-                {"name": "energy", "type": array("float")},
-                {"name": "age", "type": array("int")},
-                {"name": "birthtime", "type": array("int")},
-                {"name": "generation", "type": array("int")},
-                {"name": "unique_id", "type": array("int")},
-            ],
-        }

From bf3f327a171ed7c1fd98d344ae9bd8d41d31a2cd Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 19 Dec 2023 23:59:40 +0900
Subject: [PATCH 128/337] Fix parquet log

---
 experiments/cf_asexual_evo.py | 15 ++++-----------
 src/emevo/exp_utils.py        | 34 ++++++++++++++++++++++++++++------
 2 files changed, 32 insertions(+), 17 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index a26789bc..fa2fbf71 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -13,7 +13,6 @@
 import pyarrow as pa
 import pyarrow.parquet as pq
 import typer
-from jax._src.numpy.lax_numpy import Protocol
 from serde import toml
 
 from emevo import Env
@@ -21,7 +20,7 @@
 from emevo import make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
-from emevo.exp_utils import BDConfig, CfConfig, Log, tree_as_list
+from emevo.exp_utils import BDConfig, CfConfig, Log
 from emevo.rl.ppo_normal import (
     NormalPPONet,
     Rollout,
@@ -133,7 +132,6 @@ def step_rollout(
         )
         state_t1db, parents = env.activate(state_t1d, possible_parents)
         log = Log(
-            dead=jnp.where(dead, state_t1.profile.unique_id, -1),  # type: ignore
             parents=parents,
             rewards=rewards.ravel(),
             age=state_t1db.status.age,
@@ -246,9 +244,7 @@ def write_log(index: int) -> None:
             lambda *args: np.array(jnp.concatenate(args, axis=0)),
             *log_list,
         )
-        print(log)
         log_dict = dataclasses.asdict(log)
-        print({arr.shape for arr in log_dict.values()})
         table = pa.Table.from_pydict(log_dict)
         pq.write_table(
             table,
@@ -285,16 +281,13 @@ def write_log(index: int) -> None:
             print(f"Extinct after {i + 1} epochs")
             return pponet
 
-        import datetime as dt
+        filtered_log = log.with_step(i * n_rollout_steps).filter()
 
-        log_list.append(log)
+        log_list.append(filtered_log)
         if (i + 1) % log_interval == 0:
             index = (i + 1) // log_interval
-            print("Start parquet writing")
-            now = dt.datetime.now()
             write_log(index)
 
-            print(f"End parquet writing: {(dt.datetime.now() - now).seconds} sec")
     return pponet
 
 
@@ -318,7 +311,7 @@ def evolve(
     bdconfig_path: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
     reward_fn: RewardKind = RewardKind.LINEAR,
     logdir: Path = Path("./log"),
-    log_interval: int = 5,
+    log_interval: int = 100,
     debug_vis: bool = False,
 ) -> None:
     with cfconfig_path.open("r") as f:
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index be955779..3629730e 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -7,17 +7,13 @@
 
 import chex
 import jax
+import jax.numpy as jnp
 import serde
 
 from emevo import birth_and_death as bd
 from emevo.environments.circle_foraging import SensorRange
 
 
-def tree_as_list(pytree: Any) -> list[Any]:
-    leaves, treedef = jax.tree_util.tree_flatten(pytree)
-    return [treedef.unflatten(leaf) for leaf in zip(*leaves)]  # type: ignore
-
-
 @serde.serde
 @dataclasses.dataclass
 class CfConfig:
@@ -81,9 +77,35 @@ def load_models(self) -> tuple[bd.BirthFunction, bd.HazardFunction]:
 class Log:
     parents: jax.Array
     rewards: jax.Array
-    dead: jax.Array
     age: jax.Array
     energy: jax.Array
     birthtime: jax.Array
     generation: jax.Array
     unique_id: jax.Array
+
+    def with_step(self, from_: int) -> LogWithStep:
+        if self.parents.ndim == 2:
+            step_size, batch_size = self.parents.shape
+            arange = jnp.arange(from_, from_ + step_size)
+            step = jnp.tile(jnp.expand_dims(arange, axis=1), (1, batch_size))
+            return LogWithStep(**self, step=step)
+        elif self.parents.ndim == 1:
+            batch_size = self.parents.shape[0]
+            return LogWithStep(
+                **self,
+                step=jnp.ones(batch_size, dtype=jnp.int32) * from_,
+            )
+        else:
+            raise ValueError(
+                "with_step is only applicable for 1 or 2 dimensional log, but it has"
+                + f"{self.parents.ndim} ndim"
+            )
+
+
+@chex.dataclass
+class LogWithStep(Log):
+    step: jax.Array
+
+    def filter(self) -> Any:
+        is_active = self.unique_id > -1
+        return jax.tree_map(lambda arr: arr[is_active], self)

From 1697c14de72cae3dde156d35780936c5c3808c5a Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 20 Dec 2023 00:03:26 +0900
Subject: [PATCH 129/337] Aging

---
 src/emevo/environments/circle_foraging.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 6c6df608..f71a9934 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -647,7 +647,7 @@ def step(
             key=key,
             step=state.step + 1,
             profile=state.profile,
-            status=status,
+            status=status.step(),
             n_born_agents=state.n_born_agents,
         )
         return state, timestep

From f410b0ded18a047d6134668dac1093a5b601b4ee Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 20 Dec 2023 13:58:16 +0900
Subject: [PATCH 130/337] Implementing mutation

---
 experiments/cf_asexual_evo.py | 42 +++++++++++++++++++++++++++---
 src/emevo/exp_utils.py        |  4 +--
 src/emevo/genetic_ops.py      | 48 +++++++++++++++++++++++++++--------
 3 files changed, 78 insertions(+), 16 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index fa2fbf71..8686ef8a 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -17,6 +17,7 @@
 
 from emevo import Env
 from emevo import birth_and_death as bd
+from emevo import genetic_ops as gops
 from emevo import make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
@@ -50,8 +51,27 @@ def __call__(self, collision: jax.Array, action: jax.Array) -> jax.Array:
         return jax.vmap(jnp.dot)(input_, self.weight)
 
 
-def evolve_rewards(old, method, parents: jax.Array):
-    pass
+def mutate_reward_fn(
+    key: chex.PRNGKey,
+    reward_fn_dict: dict[int, eqx.Module],
+    old: eqx.Module,
+    mutation: gops.Mutation,
+    parents: jax.Array,
+    unique_id: jax.Array,
+) -> eqx.Module:
+    # new[i] := old[i] if i not in parents
+    # new[i] := mutation(old[parents[i]]) if i in parents
+    is_parent = parents != -1
+    if not jnp.any(is_parent):
+        return old
+    dynamic_net, static_net = eqx.partition(old, eqx.is_array)
+    keys = jax.random.split(key, jnp.sum(is_parent).item())
+    for i, key in zip(jnp.nonzero(is_parent)[0], keys):
+        parent_reward_fn = reward_fn_dict[parents[i]]
+        mutated_dnet = mutation(key, parent_reward_fn)
+        reward_fn_dict[unique_id[i]] = eqx.combine(mutated_dnet, static_net)
+        dynamic_net = jax.tree_map(lambda arr: arr[i].set(mutated_dnet), dynamic_net)
+    return eqx.combine(dynamic_net, static_net)
 
 
 class RewardKind(str, enum.Enum):
@@ -199,6 +219,7 @@ def epoch(
 def run_evolution(
     key: jax.Array,
     env: Env,
+    n_initial_agents: int,
     adam: optax.GradientTransformation,
     gamma: float,
     gae_lambda: float,
@@ -253,6 +274,11 @@ def write_log(index: int) -> None:
         )
         log_list.clear()
 
+    rewardfn_dict = {}
+    dnet, _ = eqx.partition(reward_fn, eqx.is_array)
+    for i in range(n_initial_agents):
+        rewardfn_dict[i] = jax.tree_map(lambda arr: arr[i], dnet)
+
     for i, key in enumerate(keys):
         env_state, obs, log, opt_state, pponet = epoch(
             env_state,
@@ -281,8 +307,17 @@ def write_log(index: int) -> None:
             print(f"Extinct after {i + 1} epochs")
             return pponet
 
-        filtered_log = log.with_step(i * n_rollout_steps).filter()
+        # Mutation
+        reward_fn = mutate_reward_fn(
+            key,
+            reward_fn_dict,
+            reward_fn,
+            mutation,
+            parents,
+            unique_id,
+        )
 
+        filtered_log = log.with_step(i * n_rollout_steps).filter()
         log_list.append(filtered_log)
         if (i + 1) % log_interval == 0:
             index = (i + 1) // log_interval
@@ -333,6 +368,7 @@ def evolve(
     network = run_evolution(
         key,
         env,
+        n_agents,
         optax.adam(adam_lr, eps=adam_eps),
         gamma,
         gae_lambda,
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 3629730e..d353629a 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -88,11 +88,11 @@ def with_step(self, from_: int) -> LogWithStep:
             step_size, batch_size = self.parents.shape
             arange = jnp.arange(from_, from_ + step_size)
             step = jnp.tile(jnp.expand_dims(arange, axis=1), (1, batch_size))
-            return LogWithStep(**self, step=step)
+            return LogWithStep(**dataclasses.asdict(self), step=step)
         elif self.parents.ndim == 1:
             batch_size = self.parents.shape[0]
             return LogWithStep(
-                **self,
+                **dataclasses.asdict(self),
                 step=jnp.ones(batch_size, dtype=jnp.int32) * from_,
             )
         else:
diff --git a/src/emevo/genetic_ops.py b/src/emevo/genetic_ops.py
index 633ed283..d17bb34f 100644
--- a/src/emevo/genetic_ops.py
+++ b/src/emevo/genetic_ops.py
@@ -1,4 +1,4 @@
-""" Genetics operations for array"""
+""" Genetics operations for pytree"""
 
 from __future__ import annotations
 
@@ -13,7 +13,7 @@
 
 class Crossover(abc.ABC):
     @abc.abstractmethod
-    def __call__(
+    def _select(
         self,
         prng_key: chex.PRNGKey,
         array1: jax.Array,
@@ -21,12 +21,38 @@ def __call__(
     ) -> jax.Array:
         pass
 
+    def __call__(
+        self,
+        prng_key: chex.PRNGKey,
+        params_a: chex.ArrayTree,
+        params_b: chex.ArrayTree,
+    ) -> chex.ArrayTree:
+        leaves, treedef = jax.tree_util.tree_flatten(params_a)
+        prng_keys = jax.random.split(prng_key, len(leaves))
+        result = jax.tree_map(
+            self._select,
+            treedef.unflatten(prng_keys),
+            params_a,
+            params_b,
+        )
+        return result
+
 
 class Mutation(abc.ABC):
     @abc.abstractmethod
-    def __call__(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
+    def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
         pass
 
+    def __call__(
+        self,
+        prng_key: chex.PRNGKey,
+        params: chex.ArrayTree,
+    ) -> chex.ArrayTree:
+        leaves, treedef = jax.tree_util.tree_flatten(params)
+        prng_keys = jax.random.split(prng_key, len(leaves))
+        result = jax.tree_map(self._add_noise, treedef.unflatten(prng_keys), params)
+        return result
+
 
 @dataclasses.dataclass(frozen=True)
 class UniformCrossover(Crossover):
@@ -35,7 +61,7 @@ class UniformCrossover(Crossover):
     def __post_init__(self) -> None:
         assert self.bias >= 0.0 and self.bias <= 0.5
 
-    def __call__(
+    def _select(
         self,
         prng_key: chex.PRNGKey,
         array1: jax.Array,
@@ -54,15 +80,15 @@ class CrossoverAndMutation(Crossover):
     crossover: Crossover
     mutation: Mutation
 
-    def __call__(
+    def _select(
         self,
         prng_key: chex.PRNGKey,
         array1: jax.Array,
         array2: jax.Array,
     ) -> jax.Array:
         key1, key2 = jax.random.split(prng_key)
-        selected = self.crossover(key1, array1, array2)
-        return self.mutation(key2, selected)
+        selected = self.crossover._select(key1, array1, array2)
+        return self.mutation._add_noise(key2, selected)
 
 
 @dataclasses.dataclass(frozen=True)
@@ -70,9 +96,9 @@ class BernoulliMixtureMutation(Mutation):
     mutation_prob: float
     mutator: Mutation
 
-    def __call__(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
+    def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
         key1, key2 = jax.random.split(prng_key)
-        noise_added = self.mutator(key1, array)
+        noise_added = self.mutator._add_noise(key1, array)
         is_mutated = jax.random.bernoulli(
             key2,
             self.mutation_prob,
@@ -85,7 +111,7 @@ def __call__(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
 class GaussianMutation(Mutation):
     std_dev: float
 
-    def __call__(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
+    def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
         std_normal = jax.random.normal(prng_key, shape=array.shape)
         return array + std_normal * self.std_dev
 
@@ -94,7 +120,7 @@ def __call__(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
 class UniformMutation(Mutation):
     max_noise: float
 
-    def __call__(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
+    def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
         uniform = jax.random.uniform(
             prng_key,
             shape=array.shape,

From d974bec149b6904f507c3564ac903087b43c34bb Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 20 Dec 2023 15:06:24 +0900
Subject: [PATCH 131/337] GopsConfig

---
 config/gops/20231220-mutation-01.toml |  8 ++++++++
 experiments/cf_asexual_evo.py         |  8 ++------
 src/emevo/exp_utils.py                | 27 +++++++++++++++++++++++++++
 3 files changed, 37 insertions(+), 6 deletions(-)
 create mode 100644 config/gops/20231220-mutation-01.toml

diff --git a/config/gops/20231220-mutation-01.toml b/config/gops/20231220-mutation-01.toml
new file mode 100644
index 00000000..0ee0da7b
--- /dev/null
+++ b/config/gops/20231220-mutation-01.toml
@@ -0,0 +1,8 @@
+path = "emevo.genetic_ops.BernoulliMixtureMutation"
+
+[reward]
+min_value = -1.0
+max_value = 1.0
+initial = 0.0
+
+[metadata]
\ No newline at end of file
diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 8686ef8a..0f17b04c 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -21,7 +21,7 @@
 from emevo import make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
-from emevo.exp_utils import BDConfig, CfConfig, Log
+from emevo.exp_utils import BDConfig, CfConfig, GopsConfig, Log
 from emevo.rl.ppo_normal import (
     NormalPPONet,
     Rollout,
@@ -34,11 +34,6 @@
 from emevo.visualizer import SaveVideoWrapper
 
 
-class RewardFn(Protocol):
-    def __call__(self, collision: jax.Array, action: jax.Array) -> jax.Array:
-        ...
-
-
 class LinearReward(eqx.Module):
     weight: jax.Array
 
@@ -344,6 +339,7 @@ def evolve(
     n_total_steps: int = 1024 * 10000,
     cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
     bdconfig_path: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
+    gopsconfig_path: Path = here.joinpath("../config/gops/20231220-mutation-01toml"),
     reward_fn: RewardKind = RewardKind.LINEAR,
     logdir: Path = Path("./log"),
     log_interval: int = 100,
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index d353629a..1a3c355a 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -11,6 +11,7 @@
 import serde
 
 from emevo import birth_and_death as bd
+from emevo import genetic_ops as gops
 from emevo.environments.circle_foraging import SensorRange
 
 
@@ -73,6 +74,32 @@ def load_models(self) -> tuple[bd.BirthFunction, bd.HazardFunction]:
         return birth_fn, hazard_fn
 
 
+def _resolve_cls(d: dict[str, Any]) -> GopsConfig:
+    params = {}
+    for k, v in d["params"].items():
+        if isinstance(v, dict):
+            params[k] = _resolve_cls(v)
+        else:
+            params[k] = v
+    return _load_cls(d["path"], **d["params"])
+
+
+@serde.serde
+@dataclasses.dataclass(frozen=True)
+class GopsConfig:
+    path: str
+    params: Dict[str, Union[float, Dict[str, float]]]
+
+    def load_model(self) -> gops.Mutation | gops.Crossover:
+        params = {}
+        for k, v in params.items():
+            if isinstance(v, dict):
+                params[k] = _resolve_cls(v)
+            else:
+                params[k] = v
+        return _load_cls(self.path)(**params)
+
+
 @chex.dataclass
 class Log:
     parents: jax.Array

From 56f3b027a17d189e45b1767873363c12116fbf37 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 20 Dec 2023 17:04:32 +0900
Subject: [PATCH 132/337] Test actiavate

---
 experiments/cf_asexual_evo.py             | 26 +---------
 src/emevo/env.py                          |  3 +-
 src/emevo/environments/circle_foraging.py |  5 +-
 src/emevo/genetic_ops.py                  | 16 +++----
 tests/test_activate.py                    | 58 +++++++++++++++++++++++
 5 files changed, 73 insertions(+), 35 deletions(-)
 create mode 100644 tests/test_activate.py

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 0f17b04c..d408e200 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -1,4 +1,5 @@
-"""Example of using circle foraging environment"""
+"""Asexual reward
+ evolution with Circle Foraging"""
 import dataclasses
 import enum
 from pathlib import Path
@@ -46,29 +47,6 @@ def __call__(self, collision: jax.Array, action: jax.Array) -> jax.Array:
         return jax.vmap(jnp.dot)(input_, self.weight)
 
 
-def mutate_reward_fn(
-    key: chex.PRNGKey,
-    reward_fn_dict: dict[int, eqx.Module],
-    old: eqx.Module,
-    mutation: gops.Mutation,
-    parents: jax.Array,
-    unique_id: jax.Array,
-) -> eqx.Module:
-    # new[i] := old[i] if i not in parents
-    # new[i] := mutation(old[parents[i]]) if i in parents
-    is_parent = parents != -1
-    if not jnp.any(is_parent):
-        return old
-    dynamic_net, static_net = eqx.partition(old, eqx.is_array)
-    keys = jax.random.split(key, jnp.sum(is_parent).item())
-    for i, key in zip(jnp.nonzero(is_parent)[0], keys):
-        parent_reward_fn = reward_fn_dict[parents[i]]
-        mutated_dnet = mutation(key, parent_reward_fn)
-        reward_fn_dict[unique_id[i]] = eqx.combine(mutated_dnet, static_net)
-        dynamic_net = jax.tree_map(lambda arr: arr[i].set(mutated_dnet), dynamic_net)
-    return eqx.combine(dynamic_net, static_net)
-
-
 class RewardKind(str, enum.Enum):
     LINEAR = "linear"
     SIGMOID = "sigmoid"
diff --git a/src/emevo/env.py b/src/emevo/env.py
index fc3fa5f7..f767bab2 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -87,7 +87,8 @@ def init_profile(n: int, max_n: int) -> Profile:
     return Profile(
         birthtime=jnp.concatenate((jnp.zeros(n, dtype=jnp.int32), minus_1)),
         generation=jnp.concatenate((jnp.zeros(n, dtype=jnp.int32), minus_1)),
-        unique_id=jnp.concatenate((jnp.arange(n, dtype=jnp.int32), minus_1)),
+        # unique_id starts from 1
+        unique_id=jnp.concatenate((jnp.arange(1, n + 1, dtype=jnp.int32), minus_1)),
     )
 
 
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index f71a9934..801b5dee 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -666,7 +666,10 @@ def activate(
             keys[1:],
             circle.p.xy,
         )
-        is_possible_parent = jnp.logical_and(is_parent, ok)
+        is_possible_parent = jnp.logical_and(
+            is_parent,
+            jnp.logical_and(circle.is_active, ok),
+        )
         is_replaced = _first_n_true(
             jnp.logical_not(circle.is_active),
             jnp.sum(is_possible_parent),
diff --git a/src/emevo/genetic_ops.py b/src/emevo/genetic_ops.py
index d17bb34f..bbfab444 100644
--- a/src/emevo/genetic_ops.py
+++ b/src/emevo/genetic_ops.py
@@ -4,12 +4,14 @@
 
 import abc
 import dataclasses
-from typing import cast
+from typing import Any, cast
 
 import chex
 import jax
 import jax.numpy as jnp
 
+PyTree = Any
+
 
 class Crossover(abc.ABC):
     @abc.abstractmethod
@@ -24,9 +26,9 @@ def _select(
     def __call__(
         self,
         prng_key: chex.PRNGKey,
-        params_a: chex.ArrayTree,
-        params_b: chex.ArrayTree,
-    ) -> chex.ArrayTree:
+        params_a: PyTree,
+        params_b: PyTree,
+    ) -> PyTree:
         leaves, treedef = jax.tree_util.tree_flatten(params_a)
         prng_keys = jax.random.split(prng_key, len(leaves))
         result = jax.tree_map(
@@ -43,11 +45,7 @@ class Mutation(abc.ABC):
     def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
         pass
 
-    def __call__(
-        self,
-        prng_key: chex.PRNGKey,
-        params: chex.ArrayTree,
-    ) -> chex.ArrayTree:
+    def __call__(self, prng_key: chex.PRNGKey, params: PyTree) -> PyTree:
         leaves, treedef = jax.tree_util.tree_flatten(params)
         prng_keys = jax.random.split(prng_key, len(leaves))
         result = jax.tree_map(self._add_noise, treedef.unflatten(prng_keys), params)
diff --git a/tests/test_activate.py b/tests/test_activate.py
new file mode 100644
index 00000000..f1c5216b
--- /dev/null
+++ b/tests/test_activate.py
@@ -0,0 +1,58 @@
+import typing
+
+import chex
+import jax
+import jax.numpy as jnp
+import pytest
+
+from emevo import make
+from emevo.environments.circle_foraging import CFState, CircleForaging
+
+N_MAX_AGENTS = 10
+N_INIT_AGENTS = 5
+
+
+@pytest.fixture
+def key() -> chex.PRNGKey:
+    return jax.random.PRNGKey(43)
+
+
+def reset_env(key: chex.PRNGKey) -> tuple[CircleForaging, CFState]:
+    env = make(
+        "CircleForaging-v0",
+        n_max_agents=N_MAX_AGENTS,
+        n_initial_agents=N_INIT_AGENTS,
+    )
+    state, _ = env.reset(key)
+    return typing.cast(CircleForaging, env), state
+
+
+def test_deactivate(key: chex.PRNGKey) -> None:
+    expected = jnp.array(
+        [True, True, True, True, True, False, False, False, False, False]
+    )
+    env, state = reset_env(key)
+    chex.assert_trees_all_close(state.profile.is_active(), expected)
+    state = env.deactivate(state, jnp.zeros_like(expected).at[2].set(True))
+    expected = jnp.array(
+        [True, True, False, True, True, False, False, False, False, False]
+    )
+    chex.assert_trees_all_close(state.profile.is_active(), expected)
+    nowhere = jnp.zeros((1, 2))
+    is_nowhere = jnp.all(state.physics.circle.p.xy == nowhere, axis=-1)
+    chex.assert_trees_all_close(is_nowhere, jnp.logical_not(expected))
+
+
+def test_activate(key: chex.PRNGKey) -> None:
+    env, state = reset_env(key)
+    is_parent = jnp.zeros(N_MAX_AGENTS, dtype=bool).at[jnp.array([2, 4, 7])].set(True)
+    state, parents = env.activate(state, is_parent)
+    expected_active = jnp.array(
+        [True, True, True, True, True, True, True, False, False, False]
+    )
+    chex.assert_trees_all_close(state.profile.is_active(), expected_active)
+    expected_parents = jnp.array([-1, -1, -1, -1, -1, 3, 5, -1, -1, -1])
+    chex.assert_trees_all_close(parents, expected_parents)
+    nowhere = jnp.zeros((1, 2))
+    is_nowhere = jnp.all(state.physics.circle.p.xy == nowhere, axis=-1)
+    chex.assert_trees_all_close(is_nowhere, jnp.logical_not(expected_active))

From 1a272745b511b17a6a375a58f1cc8c061bce411e Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 20 Dec 2023 17:14:43 +0900
Subject: [PATCH 133/337] Start implementing RewardFn

---
 src/emevo/reward_fn.py  | 65 +++++++++++++++++++++++++++++++++++++++++
 tests/test_reward_fn.py | 18 ++++++++++++
 2 files changed, 83 insertions(+)
 create mode 100644 src/emevo/reward_fn.py
 create mode 100644 tests/test_reward_fn.py

diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
new file mode 100644
index 00000000..65d4bec8
--- /dev/null
+++ b/src/emevo/reward_fn.py
@@ -0,0 +1,65 @@
+"""Example of using circle foraging environment"""
+from __future__ import annotations
+
+import abc
+from typing import Callable, Protocol
+
+import chex
+import equinox as eqx
+import jax
+import jax.numpy as jnp
+import numpy as np
+from numpy.typing import NDArray
+
+from emevo import genetic_ops as gops
+
+
+class RewardFn(abc.ABC, eqx.Module):
+    @abc.abstractmethod
+    def as_logdict(self) -> dict[str, float | NDArray]:
+        pass
+
+
+class LinearReward(RewardFn):
+    weight: jax.Array
+    extractor: Callable[..., jax.Array]
+    serializer: Callable[[jax.Array], jax.Array]
+
+    def __init__(
+        self,
+        key: chex.PRNGKey,
+        n_agents: int,
+        extractor: Callable[..., jax.Array],
+    ) -> None:
+        self.weight = jax.random.normal(key, (n_agents, 4))
+        self.extractor = extractor
+
+    def __call__(self, *args) -> jax.Array:
+        extracted = self.extractor(*args)
+        return jax.vmap(jnp.dot)(extracted, self.weight)
+
+    def as_logdict(self) -> dict[str, float | NDArray]:
+        return {""}
+
+
+def mutate_reward_fn(
+    key: chex.PRNGKey,
+    reward_fn_dict: dict[int, eqx.Module],
+    old: eqx.Module,
+    mutation: gops.Mutation,
+    parents: jax.Array,
+    unique_id: jax.Array,
+) -> eqx.Module:
+    # new[i] := old[i] if i not in parents
+    # new[i] := mutation(old[parents[i]]) if i in parents
+    is_parent = parents != -1
+    if not jnp.any(is_parent):
+        return old
+    dynamic_net, static_net = eqx.partition(old, eqx.is_array)
+    keys = jax.random.split(key, jnp.sum(is_parent).item())
+    for i, key in zip(jnp.nonzero(is_parent)[0], keys):
+        parent_reward_fn = reward_fn_dict[parents[i]]
+        mutated_dnet = mutation(key, parent_reward_fn)
+        reward_fn_dict[unique_id[i]] = eqx.combine(mutated_dnet, static_net)
+        dynamic_net = jax.tree_map(lambda arr: arr[i].set(mutated_dnet), dynamic_net)
+    return eqx.combine(dynamic_net, static_net)
diff --git a/tests/test_reward_fn.py b/tests/test_reward_fn.py
new file mode 100644
index 00000000..51457371
--- /dev/null
+++ b/tests/test_reward_fn.py
@@ -0,0 +1,18 @@
+import jax.numpy as jnp
+
+
+
+from emevo.reward_fn import init_status
+
+
+def test_status_clipping(n: int, capacity: float) -> None:
+    status = init_status(max_n=n, init_energy=0.0)
+    for _ in range(200):
+        status.update(energy_delta=jnp.ones(n), capacity=capacity)
+        assert jnp.all(status.energy >= 0.0)
+        assert jnp.all(status.energy <= capacity)
+
+    for _ in range(300):
+        status.update(energy_delta=jnp.ones(n) * -1.0, capacity=capacity)
+        assert jnp.all(status.energy >= 0.0)
+        assert jnp.all(status.energy <= capacity)

From 298c0c3c2b28db303d49dded37e2dd0cd1a33d9e Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 20 Dec 2023 23:09:43 +0900
Subject: [PATCH 134/337] Test gops config

---
 config/gops/20231220-mutation-01.toml | 13 ++++++++-----
 src/emevo/exp_utils.py                |  4 ++--
 src/emevo/genetic_ops.py              |  6 ++++--
 tests/test_config.py                  | 19 ++++++++++++++++---
 4 files changed, 30 insertions(+), 12 deletions(-)

diff --git a/config/gops/20231220-mutation-01.toml b/config/gops/20231220-mutation-01.toml
index 0ee0da7b..89f8abb7 100644
--- a/config/gops/20231220-mutation-01.toml
+++ b/config/gops/20231220-mutation-01.toml
@@ -1,8 +1,11 @@
 path = "emevo.genetic_ops.BernoulliMixtureMutation"
 
-[reward]
-min_value = -1.0
-max_value = 1.0
-initial = 0.0
+[params]
+mutation_prob = 0.1
 
-[metadata]
\ No newline at end of file
+[params.mutator]
+path = "emevo.genetic_ops.UniformMutation"
+
+[params.mutator.params]
+min_noise = -1.0
+max_noise = 1.0
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 1a3c355a..a99a321d 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -81,7 +81,7 @@ def _resolve_cls(d: dict[str, Any]) -> GopsConfig:
             params[k] = _resolve_cls(v)
         else:
             params[k] = v
-    return _load_cls(d["path"], **d["params"])
+    return _load_cls(d["path"])(**d["params"])
 
 
 @serde.serde
@@ -92,7 +92,7 @@ class GopsConfig:
 
     def load_model(self) -> gops.Mutation | gops.Crossover:
         params = {}
-        for k, v in params.items():
+        for k, v in self.params.items():
             if isinstance(v, dict):
                 params[k] = _resolve_cls(v)
             else:
diff --git a/src/emevo/genetic_ops.py b/src/emevo/genetic_ops.py
index bbfab444..2eabfa2a 100644
--- a/src/emevo/genetic_ops.py
+++ b/src/emevo/genetic_ops.py
@@ -116,12 +116,14 @@ def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
 
 @dataclasses.dataclass(frozen=True)
 class UniformMutation(Mutation):
+    min_noise: float
     max_noise: float
 
     def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
         uniform = jax.random.uniform(
             prng_key,
             shape=array.shape,
-            maxval=self.max_noise * 2,
+            minval=self.min_noise,
+            maxval=self.max_noise,
         )
-        return array + uniform - self.max_noise
+        return array + uniform
diff --git a/tests/test_config.py b/tests/test_config.py
index 53baea19..27286be6 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -1,11 +1,12 @@
 from serde import toml
 
 from emevo import birth_and_death as bd
-from emevo.exp_utils import BDConfig, CfConfig
+from emevo import genetic_ops as gops
+from emevo.exp_utils import BDConfig, CfConfig, GopsConfig
 
 
 def test_bdconfig() -> None:
-    with open("config/bd/20230530-a035-e020.toml", "r") as f:
+    with open("config/bd/20230530-a035-e020.toml") as f:
         bdconfig = toml.from_toml(BDConfig, f.read())
 
     birth_fn, hazard_fn = bdconfig.load_models()
@@ -14,7 +15,19 @@ def test_bdconfig() -> None:
 
 
 def test_cfconfig() -> None:
-    with open("config/env/20231214-square.toml", "r") as f:
+    with open("config/env/20231214-square.toml") as f:
         cfconfig = toml.from_toml(CfConfig, f.read())
 
     assert cfconfig.sensor_range == "wide"
+
+
+def test_gopsconfig() -> None:
+    with open("config/gops/20231220-mutation-01.toml") as f:
+        gopsconfig = toml.from_toml(GopsConfig, f.read())
+
+    mutation = gopsconfig.load_model()
+    assert isinstance(mutation, gops.BernoulliMixtureMutation)
+    assert mutation.mutation_prob == 0.1
+    assert isinstance(mutation.mutator, gops.UniformMutation)
+    assert mutation.mutator.min_noise == -1
+    assert mutation.mutator.max_noise == 1

From e53498e4b2770710fb21a77e670d2d894ad4e2dd Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 21 Dec 2023 00:58:36 +0900
Subject: [PATCH 135/337] Test reward_fn

---
 config/gops/20231220-mutation-01.toml |  2 +-
 experiments/cf_asexual_evo.py         |  7 +++-
 pyproject.toml                        |  1 -
 src/emevo/reward_fn.py                | 44 ++++++++++++++++----
 tests/test_reward_fn.py               | 59 ++++++++++++++++++++++-----
 5 files changed, 91 insertions(+), 22 deletions(-)

diff --git a/config/gops/20231220-mutation-01.toml b/config/gops/20231220-mutation-01.toml
index 89f8abb7..b7140649 100644
--- a/config/gops/20231220-mutation-01.toml
+++ b/config/gops/20231220-mutation-01.toml
@@ -1,7 +1,7 @@
 path = "emevo.genetic_ops.BernoulliMixtureMutation"
 
 [params]
-mutation_prob = 0.1
+mutation_prob = 0.2
 
 [params.mutator]
 path = "emevo.genetic_ops.UniformMutation"
diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index d408e200..75bb7b34 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -323,15 +323,20 @@ def evolve(
     log_interval: int = 100,
     debug_vis: bool = False,
 ) -> None:
+    # Load config
     with cfconfig_path.open("r") as f:
         cfconfig = toml.from_toml(CfConfig, f.read())
     with bdconfig_path.open("r") as f:
         bdconfig = toml.from_toml(BDConfig, f.read())
+    with gopsconfig_path.open("r") as f:
+        gopsconfig = toml.from_toml(GopsConfig, f.read())
 
+    # Load models
+    birth_fn, hazard_fn = bdconfig.load_models()
+    mutation = gopsconfig.load_model()
     # Override config
     cfconfig.n_initial_agents = n_agents
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
-    birth_fn, hazard_fn = bdconfig.load_models()
     key, reward_key = jax.random.split(jax.random.PRNGKey(seed))
     if reward_fn == RewardKind.LINEAR:
         reward_fn_instance = LinearReward(reward_key, cfconfig.n_max_agents)
diff --git a/pyproject.toml b/pyproject.toml
index 54fde431..d3a4737a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -57,7 +57,6 @@ profile = "black"
 
 [tool.ruff]
 line-length = 88
-# ignore = ["UP035"]
 select = ["E", "F", "B", "UP"]
 
 [tool.ruff.per-file-ignores]
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 65d4bec8..d8464cfd 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 import abc
-from typing import Callable, Protocol
+from typing import Any, Callable
 
 import chex
 import equinox as eqx
@@ -13,12 +13,33 @@
 
 from emevo import genetic_ops as gops
 
+Self = Any
+
 
 class RewardFn(abc.ABC, eqx.Module):
     @abc.abstractmethod
-    def as_logdict(self) -> dict[str, float | NDArray]:
+    def serialize(self) -> dict[str, float | NDArray]:
         pass
 
+    def get_slice(
+        self,
+        slice_idx: int | jax.Array,
+        include_static: bool = False,
+    ) -> Self:
+        dynamic, static = eqx.partition(self, eqx.is_array)
+        sliced_dyn = jax.tree_map(lambda item: item[slice_idx], dynamic)
+        if include_static:
+            return eqx.combine(sliced_dyn, static)
+        else:
+            return sliced_dyn
+
+
+def _item_or_np(array: jax.Array) -> float | NDArray:
+    if array.ndim == 0:
+        return array.item()
+    else:
+        return np.array(array)
+
 
 class LinearReward(RewardFn):
     weight: jax.Array
@@ -29,17 +50,20 @@ def __init__(
         self,
         key: chex.PRNGKey,
         n_agents: int,
+        n_weights: int,
         extractor: Callable[..., jax.Array],
+        serializer: Callable[[jax.Array], dict[str, jax.Array]],
     ) -> None:
-        self.weight = jax.random.normal(key, (n_agents, 4))
+        self.weight = jax.random.normal(key, (n_agents, n_weights))
         self.extractor = extractor
+        self.serializer = serializer
 
     def __call__(self, *args) -> jax.Array:
         extracted = self.extractor(*args)
         return jax.vmap(jnp.dot)(extracted, self.weight)
 
-    def as_logdict(self) -> dict[str, float | NDArray]:
-        return {""}
+    def serialize(self) -> dict[str, float | NDArray]:
+        return jax.tree_map(_item_or_np, self.serializer(self.weight))
 
 
 def mutate_reward_fn(
@@ -58,8 +82,12 @@ def mutate_reward_fn(
     dynamic_net, static_net = eqx.partition(old, eqx.is_array)
     keys = jax.random.split(key, jnp.sum(is_parent).item())
     for i, key in zip(jnp.nonzero(is_parent)[0], keys):
-        parent_reward_fn = reward_fn_dict[parents[i]]
+        parent_reward_fn = reward_fn_dict[parents[i].item()]
         mutated_dnet = mutation(key, parent_reward_fn)
-        reward_fn_dict[unique_id[i]] = eqx.combine(mutated_dnet, static_net)
-        dynamic_net = jax.tree_map(lambda arr: arr[i].set(mutated_dnet), dynamic_net)
+        reward_fn_dict[unique_id[i].item()] = eqx.combine(mutated_dnet, static_net)
+        dynamic_net = jax.tree_map(
+            lambda orig, mutated: orig.at[i].set(mutated),
+            dynamic_net,
+            mutated_dnet,
+        )
     return eqx.combine(dynamic_net, static_net)
diff --git a/tests/test_reward_fn.py b/tests/test_reward_fn.py
index 51457371..f9947ee0 100644
--- a/tests/test_reward_fn.py
+++ b/tests/test_reward_fn.py
@@ -1,18 +1,55 @@
+import chex
+import jax
 import jax.numpy as jnp
+import pytest
 
+from emevo import genetic_ops as gops
+from emevo.reward_fn import LinearReward, mutate_reward_fn
 
 
-from emevo.reward_fn import init_status
+@pytest.fixture
+def reward_fn() -> chex.PRNGKey:
+    def slice_last(w: jax.Array, i: int) -> jax.Array:
+        return jnp.squeeze(jax.lax.slice_in_dim(w, i, i + 1, axis=-1))
 
+    return LinearReward(
+        jax.random.PRNGKey(43),
+        10,
+        3,
+        lambda x: x,  # Nothing to do
+        lambda w: {"a": slice_last(w, 0), "b": slice_last(w, 1), "c": slice_last(w, 2)},
+    )
 
-def test_status_clipping(n: int, capacity: float) -> None:
-    status = init_status(max_n=n, init_energy=0.0)
-    for _ in range(200):
-        status.update(energy_delta=jnp.ones(n), capacity=capacity)
-        assert jnp.all(status.energy >= 0.0)
-        assert jnp.all(status.energy <= capacity)
 
-    for _ in range(300):
-        status.update(energy_delta=jnp.ones(n) * -1.0, capacity=capacity)
-        assert jnp.all(status.energy >= 0.0)
-        assert jnp.all(status.energy <= capacity)
+def test_reward_fn(reward_fn: LinearReward) -> None:
+    inputs = jnp.zeros((10, 3))
+    reward = reward_fn(inputs)
+    chex.assert_shape(reward, (10,))
+
+
+def test_serialize(reward_fn: LinearReward) -> None:
+    logd = reward_fn.serialize()
+    chex.assert_shape((logd["a"], logd["b"], logd["c"]), (10,))
+
+
+def test_mutation(reward_fn: LinearReward) -> None:
+    reward_fn_dict = {i + 1: reward_fn.get_slice(i) for i in range(5)}
+    chex.assert_shape(tuple(map(lambda lr: lr.weight, reward_fn_dict.values())), (3,))
+    mutation = gops.GaussianMutation(std_dev=1.0)
+    parents = jnp.array([-1, -1, -1, -1, -1, 2, 4, -1, -1, -1])
+    mutated = mutate_reward_fn(
+        jax.random.PRNGKey(23),
+        reward_fn_dict,
+        reward_fn,
+        mutation,
+        parents=parents,
+        unique_id=jnp.array([1, 2, 3, 4, 5, 6, 7, -1, -1, -1]),
+    )
+    same = parents == -1
+    chex.assert_trees_all_close(reward_fn.weight[same], mutated.weight[same])
+    different = parents != -1
+    difference = reward_fn.weight[different] - mutated.weight[different]
+    assert jnp.linalg.norm(difference) > 1e-6
+    assert len(reward_fn_dict) == 7
+    for i in range(7):
+        chex.assert_trees_all_close(mutated.weight[i], reward_fn_dict[i + 1].weight)

From 21115b796321f2593d8829e4af11a5634843d229 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 21 Dec 2023 01:27:31 +0900
Subject: [PATCH 136/337] Ignore some ruff errors

---
 pyproject.toml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index d3a4737a..3cf64a42 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -61,8 +61,9 @@ select = ["E", "F", "B", "UP"]
 
 [tool.ruff.per-file-ignores]
 "__init__.py" = ["F401"]
+"src/emevo/reward_fn.py" = ["B023"]
 # For pyserde
-"src/emevo/exp_utils.py" = ["UP006", "UP035"]
+"src/emevo/exp_utils.py" = ["UP006", "UP007", "UP035"]
 # For typer
 "experiments/**/*.py" = ["B008", "UP006", "UP007"]
 "smoke-tests/*.py" = ["B008", "UP006", "UP007"]
\ No newline at end of file

From bf7251f011a4d1aa0fa6bd38391192d0e0431e8e Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 21 Dec 2023 01:52:17 +0900
Subject: [PATCH 137/337] muate_reward_fn takes filtered log

---
 experiments/cf_asexual_evo.py | 15 +++++++--------
 src/emevo/exp_utils.py        | 10 +++++++---
 src/emevo/reward_fn.py        | 17 +++++++----------
 tests/test_reward_fn.py       |  5 +++--
 4 files changed, 24 insertions(+), 23 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 75bb7b34..76619c61 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -23,6 +23,7 @@
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
 from emevo.exp_utils import BDConfig, CfConfig, GopsConfig, Log
+from emevo.reward_fn import mutate_reward_fn
 from emevo.rl.ppo_normal import (
     NormalPPONet,
     Rollout,
@@ -203,6 +204,7 @@ def run_evolution(
     reward_fn: LinearReward,
     hazard_fn: bd.HazardFunction,
     birth_fn: bd.BirthFunction,
+    mutation: gops.Mutation,
     logdir: Path,
     log_interval: int,
     xmax: float,
@@ -247,11 +249,7 @@ def write_log(index: int) -> None:
         )
         log_list.clear()
 
-    rewardfn_dict = {}
-    dnet, _ = eqx.partition(reward_fn, eqx.is_array)
-    for i in range(n_initial_agents):
-        rewardfn_dict[i] = jax.tree_map(lambda arr: arr[i], dnet)
-
+    reward_fn_dict = {i + 1: reward_fn.get_slice(i) for i in range(n_initial_agents)}
     for i, key in enumerate(keys):
         env_state, obs, log, opt_state, pponet = epoch(
             env_state,
@@ -281,16 +279,17 @@ def write_log(index: int) -> None:
             return pponet
 
         # Mutation
+        filtered_log = log.with_step(i * n_rollout_steps).filter()
         reward_fn = mutate_reward_fn(
             key,
             reward_fn_dict,
             reward_fn,
             mutation,
-            parents,
-            unique_id,
+            filtered_log.parents,
+            filtered_log.unique_id,
+            filtered_log.slots,
         )
 
-        filtered_log = log.with_step(i * n_rollout_steps).filter()
         log_list.append(filtered_log)
         if (i + 1) % log_interval == 0:
             index = (i + 1) // log_interval
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index a99a321d..88dfb9c1 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -113,14 +113,17 @@ class Log:
     def with_step(self, from_: int) -> LogWithStep:
         if self.parents.ndim == 2:
             step_size, batch_size = self.parents.shape
-            arange = jnp.arange(from_, from_ + step_size)
-            step = jnp.tile(jnp.expand_dims(arange, axis=1), (1, batch_size))
-            return LogWithStep(**dataclasses.asdict(self), step=step)
+            step_arange = jnp.arange(from_, from_ + step_size)
+            step = jnp.tile(jnp.expand_dims(step_arange, axis=1), (1, batch_size))
+            slots_arange = jnp.arange(batch_size)
+            slots = jnp.tile(jnp.expand_dims(slots_arange, axis=1), (step_size, 1))
+            return LogWithStep(**dataclasses.asdict(self), step=step, slots=slots)
         elif self.parents.ndim == 1:
             batch_size = self.parents.shape[0]
             return LogWithStep(
                 **dataclasses.asdict(self),
                 step=jnp.ones(batch_size, dtype=jnp.int32) * from_,
+                slots=jnp.arange(batch_size),
             )
         else:
             raise ValueError(
@@ -132,6 +135,7 @@ def with_step(self, from_: int) -> LogWithStep:
 @chex.dataclass
 class LogWithStep(Log):
     step: jax.Array
+    slots: jax.Array
 
     def filter(self) -> Any:
         is_active = self.unique_id > -1
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index d8464cfd..9572f07b 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -73,20 +73,17 @@ def mutate_reward_fn(
     mutation: gops.Mutation,
     parents: jax.Array,
     unique_id: jax.Array,
+    slots: jax.Array,
 ) -> eqx.Module:
-    # new[i] := old[i] if i not in parents
-    # new[i] := mutation(old[parents[i]]) if i in parents
-    is_parent = parents != -1
-    if not jnp.any(is_parent):
-        return old
+    n = parents.shape[0]
     dynamic_net, static_net = eqx.partition(old, eqx.is_array)
-    keys = jax.random.split(key, jnp.sum(is_parent).item())
-    for i, key in zip(jnp.nonzero(is_parent)[0], keys):
-        parent_reward_fn = reward_fn_dict[parents[i].item()]
+    keys = jax.random.split(key, n)
+    for key, parent, uid, slot in zip(keys, parents, unique_id, slots):
+        parent_reward_fn = reward_fn_dict[parent.item()]
         mutated_dnet = mutation(key, parent_reward_fn)
-        reward_fn_dict[unique_id[i].item()] = eqx.combine(mutated_dnet, static_net)
+        reward_fn_dict[uid.item()] = eqx.combine(mutated_dnet, static_net)
         dynamic_net = jax.tree_map(
-            lambda orig, mutated: orig.at[i].set(mutated),
+            lambda orig, mutated: orig.at[slot.item()].set(mutated),
             dynamic_net,
             mutated_dnet,
         )
diff --git a/tests/test_reward_fn.py b/tests/test_reward_fn.py
index f9947ee0..fdc9bba6 100644
--- a/tests/test_reward_fn.py
+++ b/tests/test_reward_fn.py
@@ -42,8 +42,9 @@ def test_mutation(reward_fn: LinearReward) -> None:
         reward_fn_dict,
         reward_fn,
         mutation,
-        parents=parents,
-        unique_id=jnp.array([1, 2, 3, 4, 5, 6, 7, -1, -1, -1]),
+        parents=parents[5:7],
+        unique_id=jnp.array([6, 7]),
+        slots=jnp.array([5, 6]),
     )
     same = parents == -1
     chex.assert_trees_all_close(reward_fn.weight[same], mutated.weight[same])

From 9ffcfe043e6ba31be35f1ec98c01c4764cef6e7d Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 21 Dec 2023 12:11:52 +0900
Subject: [PATCH 138/337] Several bug fixes

---
 experiments/cf_asexual_evo.py | 89 ++++++++++++++++++++---------------
 src/emevo/exp_utils.py        |  8 +++-
 src/emevo/reward_fn.py        | 13 +++--
 tests/test_reward_fn.py       |  2 +-
 4 files changed, 65 insertions(+), 47 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 76619c61..31b045d2 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -3,7 +3,7 @@
 import dataclasses
 import enum
 from pathlib import Path
-from typing import Protocol
+from typing import cast
 
 import chex
 import equinox as eqx
@@ -23,7 +23,7 @@
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
 from emevo.exp_utils import BDConfig, CfConfig, GopsConfig, Log
-from emevo.reward_fn import mutate_reward_fn
+from emevo.reward_fn import LinearReward, RewardFn, mutate_reward_fn
 from emevo.rl.ppo_normal import (
     NormalPPONet,
     Rollout,
@@ -36,16 +36,13 @@
 from emevo.visualizer import SaveVideoWrapper
 
 
-class LinearReward(eqx.Module):
-    weight: jax.Array
+def extract_reward_input(collision: jax.Array, action: jax.Array) -> jax.Array:
+    action_norm = jnp.sqrt(jnp.sum(action**2, axis=-1, keepdims=True))
+    return jnp.concatenate((collision, action_norm), axis=1)
 
-    def __init__(self, key: chex.PRNGKey, n_agents: int) -> None:
-        self.weight = jax.random.normal(key, (n_agents, 4))
 
-    def __call__(self, collision: jax.Array, action: jax.Array) -> jax.Array:
-        action_norm = jnp.sqrt(jnp.sum(action**2, axis=-1, keepdims=True))
-        input_ = jnp.concatenate((collision, action_norm), axis=1)
-        return jax.vmap(jnp.dot)(input_, self.weight)
+def slice_last(w: jax.Array, i: int) -> jax.Array:
+    return jnp.squeeze(jax.lax.slice_in_dim(w, i, i + 1, axis=-1))
 
 
 class RewardKind(str, enum.Enum):
@@ -89,7 +86,7 @@ def exec_rollout(
     initial_obs: Obs,
     env: Env,
     network: NormalPPONet,
-    reward_fn: LinearReward,
+    reward_fn: RewardFn,
     hazard_fn: bd.HazardFunction,
     birth_fn: bd.BirthFunction,
     prng_key: jax.Array,
@@ -151,7 +148,7 @@ def epoch(
     initial_obs: Obs,
     env: Env,
     network: NormalPPONet,
-    reward_fn: LinearReward,
+    reward_fn: RewardFn,
     hazard_fn: bd.HazardFunction,
     birth_fn: bd.BirthFunction,
     prng_key: jax.Array,
@@ -191,6 +188,7 @@ def epoch(
 
 
 def run_evolution(
+    *,
     key: jax.Array,
     env: Env,
     n_initial_agents: int,
@@ -201,7 +199,7 @@ def run_evolution(
     minibatch_size: int,
     n_rollout_steps: int,
     n_total_steps: int,
-    reward_fn: LinearReward,
+    reward_fn: RewardFn,
     hazard_fn: bd.HazardFunction,
     birth_fn: bd.BirthFunction,
     mutation: gops.Mutation,
@@ -209,7 +207,7 @@ def run_evolution(
     log_interval: int,
     xmax: float,
     ymax: float,
-    debug_vis: bool = False,
+    debug_vis: bool,
 ) -> NormalPPONet:
     key, net_key, reset_key = jax.random.split(key, 3)
     obs_space = env.obs_space.flatten()
@@ -279,18 +277,19 @@ def write_log(index: int) -> None:
             return pponet
 
         # Mutation
-        filtered_log = log.with_step(i * n_rollout_steps).filter()
+        log_with_step = log.with_step(i * n_rollout_steps)
+        log_birth = log_with_step.filter_birth()
         reward_fn = mutate_reward_fn(
             key,
             reward_fn_dict,
             reward_fn,
             mutation,
-            filtered_log.parents,
-            filtered_log.unique_id,
-            filtered_log.slots,
+            log_birth.parents,
+            log_birth.unique_id,
+            log_birth.slots,
         )
 
-        log_list.append(filtered_log)
+        log_list.append(log_with_step.filter_active())
         if (i + 1) % log_interval == 0:
             index = (i + 1) // log_interval
             write_log(index)
@@ -316,7 +315,7 @@ def evolve(
     n_total_steps: int = 1024 * 10000,
     cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
     bdconfig_path: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
-    gopsconfig_path: Path = here.joinpath("../config/gops/20231220-mutation-01toml"),
+    gopsconfig_path: Path = here.joinpath("../config/gops/20231220-mutation-01.toml"),
     reward_fn: RewardKind = RewardKind.LINEAR,
     logdir: Path = Path("./log"),
     log_interval: int = 100,
@@ -338,30 +337,42 @@ def evolve(
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
     key, reward_key = jax.random.split(jax.random.PRNGKey(seed))
     if reward_fn == RewardKind.LINEAR:
-        reward_fn_instance = LinearReward(reward_key, cfconfig.n_max_agents)
+        reward_fn_instance = LinearReward(
+            reward_key,
+            cfconfig.n_max_agents,
+            4,
+            extract_reward_input,
+            lambda w: {
+                "agent": slice_last(w, 0),
+                "food": slice_last(w, 1),
+                "wall": slice_last(w, 2),
+                "energy": slice_last(w, 3),
+            },
+        )
     elif reward_fn == RewardKind.SIGMOID:
         assert False, "Unimplemented"
     else:
         raise ValueError(f"Invalid reward_fn {reward_fn}")
     network = run_evolution(
-        key,
-        env,
-        n_agents,
-        optax.adam(adam_lr, eps=adam_eps),
-        gamma,
-        gae_lambda,
-        n_optim_epochs,
-        minibatch_size,
-        n_rollout_steps,
-        n_total_steps,
-        reward_fn_instance,
-        hazard_fn,
-        birth_fn,
-        logdir,
-        log_interval,
-        cfconfig.xlim[1],
-        cfconfig.ylim[1],
-        debug_vis,
+        key=key,
+        env=env,
+        n_initial_agents=n_agents,
+        adam=optax.adam(adam_lr, eps=adam_eps),
+        gamma=gamma,
+        gae_lambda=gae_lambda,
+        n_optim_epochs=n_optim_epochs,
+        minibatch_size=minibatch_size,
+        n_rollout_steps=n_rollout_steps,
+        n_total_steps=n_total_steps,
+        reward_fn=reward_fn_instance,
+        hazard_fn=hazard_fn,
+        birth_fn=birth_fn,
+        mutation=cast(gops.Mutation, mutation),
+        logdir=logdir,
+        log_interval=log_interval,
+        xmax=cfconfig.xlim[1],
+        ymax=cfconfig.ylim[1],
+        debug_vis=debug_vis,
     )
     # eqx.tree_serialise_leaves(modelpath, network)
 
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 88dfb9c1..dbf1085e 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -116,7 +116,7 @@ def with_step(self, from_: int) -> LogWithStep:
             step_arange = jnp.arange(from_, from_ + step_size)
             step = jnp.tile(jnp.expand_dims(step_arange, axis=1), (1, batch_size))
             slots_arange = jnp.arange(batch_size)
-            slots = jnp.tile(jnp.expand_dims(slots_arange, axis=1), (step_size, 1))
+            slots = jnp.tile(slots_arange, (step_size, 1))
             return LogWithStep(**dataclasses.asdict(self), step=step, slots=slots)
         elif self.parents.ndim == 1:
             batch_size = self.parents.shape[0]
@@ -137,6 +137,10 @@ class LogWithStep(Log):
     step: jax.Array
     slots: jax.Array
 
-    def filter(self) -> Any:
+    def filter_active(self) -> Any:
         is_active = self.unique_id > -1
         return jax.tree_map(lambda arr: arr[is_active], self)
+
+    def filter_birth(self) -> Any:
+        is_birth_event = self.parents > -1
+        return jax.tree_map(lambda arr: arr[is_birth_event], self)
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 9572f07b..0935b78e 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 import abc
-from typing import Any, Callable
+from typing import Any, Callable, TypeVar
 
 import chex
 import equinox as eqx
@@ -34,6 +34,9 @@ def get_slice(
             return sliced_dyn
 
 
+RF = TypeVar("RF", bound=RewardFn)
+
+
 def _item_or_np(array: jax.Array) -> float | NDArray:
     if array.ndim == 0:
         return array.item()
@@ -44,7 +47,7 @@ def _item_or_np(array: jax.Array) -> float | NDArray:
 class LinearReward(RewardFn):
     weight: jax.Array
     extractor: Callable[..., jax.Array]
-    serializer: Callable[[jax.Array], jax.Array]
+    serializer: Callable[[jax.Array], dict[str, jax.Array]]
 
     def __init__(
         self,
@@ -68,13 +71,13 @@ def serialize(self) -> dict[str, float | NDArray]:
 
 def mutate_reward_fn(
     key: chex.PRNGKey,
-    reward_fn_dict: dict[int, eqx.Module],
-    old: eqx.Module,
+    reward_fn_dict: dict[int, RF],
+    old: RF,
     mutation: gops.Mutation,
     parents: jax.Array,
     unique_id: jax.Array,
     slots: jax.Array,
-) -> eqx.Module:
+) -> RF:
     n = parents.shape[0]
     dynamic_net, static_net = eqx.partition(old, eqx.is_array)
     keys = jax.random.split(key, n)
diff --git a/tests/test_reward_fn.py b/tests/test_reward_fn.py
index fdc9bba6..a27af3fd 100644
--- a/tests/test_reward_fn.py
+++ b/tests/test_reward_fn.py
@@ -8,7 +8,7 @@
 
 
 @pytest.fixture
-def reward_fn() -> chex.PRNGKey:
+def reward_fn() -> LinearReward:
     def slice_last(w: jax.Array, i: int) -> jax.Array:
         return jnp.squeeze(jax.lax.slice_in_dim(w, i, i + 1, axis=-1))
 

From c57342319c2636b75d2481531a69aad94fb1534f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 21 Dec 2023 17:59:07 +0900
Subject: [PATCH 139/337] Reset network for newborns

---
 experiments/cf_asexual_evo.py | 100 +++++++++++++++++++++++++---------
 pyproject.toml                |   2 +-
 src/emevo/eqx_utils.py        |  25 +++++++++
 src/emevo/exp_utils.py        |   5 ++
 src/emevo/reward_fn.py        |  16 ++----
 tests/test_config.py          |   2 +-
 tests/test_reward_fn.py       |   3 +-
 7 files changed, 113 insertions(+), 40 deletions(-)
 create mode 100644 src/emevo/eqx_utils.py

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 31b045d2..43ed97a2 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -3,7 +3,7 @@
 import dataclasses
 import enum
 from pathlib import Path
-from typing import cast
+from typing import NamedTuple, cast
 
 import chex
 import equinox as eqx
@@ -22,6 +22,8 @@
 from emevo import make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
+from emevo.eqx_utils import get_slice
+from emevo.eqx_utils import where as eqx_where
 from emevo.exp_utils import BDConfig, CfConfig, GopsConfig, Log
 from emevo.reward_fn import LinearReward, RewardFn, mutate_reward_fn
 from emevo.rl.ppo_normal import (
@@ -123,6 +125,7 @@ def step_rollout(
         )
         state_t1db, parents = env.activate(state_t1d, possible_parents)
         log = Log(
+            dead=jnp.where(dead, state_t.profile.unique_id, -1),
             parents=parents,
             rewards=rewards.ravel(),
             age=state_t1db.status.age,
@@ -208,24 +211,30 @@ def run_evolution(
     xmax: float,
     ymax: float,
     debug_vis: bool,
-) -> NormalPPONet:
+) -> None:
     key, net_key, reset_key = jax.random.split(key, 3)
     obs_space = env.obs_space.flatten()
     input_size = np.prod(obs_space.shape)
     act_size = np.prod(env.act_space.shape)
-    pponet = vmap_net(
-        input_size,
-        64,
-        act_size,
-        jax.random.split(net_key, env.n_max_agents),
-    )
+
+    def initialize_net(key: chex.PRNGKey) -> NormalPPONet:
+        return vmap_net(
+            input_size,
+            64,
+            act_size,
+            jax.random.split(key, env.n_max_agents),
+        )
+
+    pponet = initialize_net(net_key)
     adam_init, adam_update = adam
-    opt_state = jax.vmap(adam_init)(eqx.filter(pponet, eqx.is_array))
+
+    def initialize_opt_state(net: eqx.Module) -> optax.OptState:
+        return jax.vmap(adam_init)(eqx.filter(net, eqx.is_array))
+
+    opt_state = initialize_opt_state(pponet)
     env_state, timestep = env.reset(reset_key)
     obs = timestep.obs
 
-    n_loop = n_total_steps // n_rollout_steps
-    keys = jax.random.split(key, n_loop)
     if debug_vis:
         visualizer = env.visualizer(env_state, figsize=(xmax * 2, ymax * 2))
     else:
@@ -239,16 +248,44 @@ def write_log(index: int) -> None:
             *log_list,
         )
         log_dict = dataclasses.asdict(log)
-        table = pa.Table.from_pydict(log_dict)
         pq.write_table(
-            table,
+            pa.Table.from_pydict(log_dict),
             logdir.joinpath(f"log-{index}.parquet"),
             compression="zstd",
         )
         log_list.clear()
 
-    reward_fn_dict = {i + 1: reward_fn.get_slice(i) for i in range(n_initial_agents)}
-    for i, key in enumerate(keys):
+    def save_agents(unique_id: jax.Array, slots: jax.Array) -> None:
+        for uid, slot in zip(np.array(unique_id), np.array(slots)):
+            network = get_slice(pponet, slot)
+            modelpath = logdir.joinpath(f"trained-{uid}.eqx")
+            eqx.tree_serialise_leaves(modelpath, network)
+
+    @eqx.filter_jit
+    def replace_net(
+        key: chex.PRNGKey,
+        flag: jax.Array,
+        pponet: NormalPPONet,
+        opt_state: optax.OptState,
+    ) -> tuple[NormalPPONet, optax.OptState]:
+        initialized = initialize_net(key)
+        pponet = eqx_where(flag, initialized, pponet)
+        opt_state = jax.tree_map(
+            lambda a, b: jnp.where(
+                jnp.expand_dims(flag, tuple(range(1, a.ndim))),
+                b,
+                a,
+            ),
+            opt_state,
+            initialize_opt_state(pponet),
+        )
+        return pponet, opt_state
+
+    reward_fn_dict = {i + 1: get_slice(reward_fn, i) for i in range(n_initial_agents)}
+
+    last_log_index = 0
+    for i, key in enumerate(jax.random.split(key, n_total_steps // n_rollout_steps)):
+        epoch_key, init_key = jax.random.split(key)
         env_state, obs, log, opt_state, pponet = epoch(
             env_state,
             obs,
@@ -257,7 +294,7 @@ def write_log(index: int) -> None:
             reward_fn,
             hazard_fn,
             birth_fn,
-            key,
+            epoch_key,
             n_rollout_steps,
             gamma,
             gae_lambda,
@@ -269,16 +306,23 @@ def write_log(index: int) -> None:
         if visualizer is not None:
             visualizer.render(env_state)
             visualizer.show()
-
         # Extinct?
         n_active = jnp.sum(env_state.profile.is_active())
         if n_active == 0:
             print(f"Extinct after {i + 1} epochs")
-            return pponet
+            break
 
-        # Mutation
+        # Save network
         log_with_step = log.with_step(i * n_rollout_steps)
+        log_death = log_with_step.filter_death()
+        save_agents(log_death.dead, log_death.slots)
         log_birth = log_with_step.filter_birth()
+        # Initialize network and adam state for new agents
+        is_new = jnp.zeros(env.n_max_agents, dtype=bool).at[log_birth.slots].set(True)
+        if jnp.any(is_new):
+            pponet, opt_state = replace_net(init_key, is_new, pponet, opt_state)
+
+        # Mutation
         reward_fn = mutate_reward_fn(
             key,
             reward_fn_dict,
@@ -291,10 +335,17 @@ def write_log(index: int) -> None:
 
         log_list.append(log_with_step.filter_active())
         if (i + 1) % log_interval == 0:
-            index = (i + 1) // log_interval
-            write_log(index)
-
-    return pponet
+            write_log(last_log_index + 1)
+            last_log_index += 1
+    rfd_serialized = [
+        v.serialize() | {"unique_id": k} for k, v in reward_fn_dict.items()
+    ]
+    pq.write_table(
+        pa.Table.from_pylist(rfd_serialized),
+        logdir.joinpath(f"rewards.parquet"),
+    )
+    if len(log_list) > 0:
+        write_log(last_log_index + 1)
 
 
 app = typer.Typer(pretty_exceptions_show_locals=False)
@@ -353,7 +404,7 @@ def evolve(
         assert False, "Unimplemented"
     else:
         raise ValueError(f"Invalid reward_fn {reward_fn}")
-    network = run_evolution(
+    run_evolution(
         key=key,
         env=env,
         n_initial_agents=n_agents,
@@ -374,7 +425,6 @@ def evolve(
         ymax=cfconfig.ylim[1],
         debug_vis=debug_vis,
     )
-    # eqx.tree_serialise_leaves(modelpath, network)
 
 
 @app.command()
diff --git a/pyproject.toml b/pyproject.toml
index 3cf64a42..d29b05b3 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -31,7 +31,7 @@ dependencies = [
 dynamic = ["version"]
 
 [project.optional-dependencies]
-pyside6 = ["PySide6 >= 6.4.1"]
+pyside6 = ["PySide6 >= 6.5"]
 video = ["imageio-ffmpeg >= 0.4"]
 
 [project.readme]
diff --git a/src/emevo/eqx_utils.py b/src/emevo/eqx_utils.py
new file mode 100644
index 00000000..99e78cd2
--- /dev/null
+++ b/src/emevo/eqx_utils.py
@@ -0,0 +1,25 @@
+from typing import TypeVar
+
+import equinox as eqx
+import jax
+import jax.numpy as jnp
+
+M = TypeVar("M", bound=eqx.Module)
+
+
+def get_slice(module: M, slice_idx: int | jax.Array) -> M:
+    dynamic, static = eqx.partition(module, eqx.is_array)
+    sliced_dyn = jax.tree_map(lambda item: item[slice_idx], dynamic)
+    return eqx.combine(sliced_dyn, static)
+
+
+@eqx.filter_jit
+def where(flag: jax.Array, mod_a: M, mod_b: M) -> M:
+    dyn_a, static = eqx.partition(mod_a, eqx.is_array)
+    dyn_b, _ = eqx.partition(mod_b, eqx.is_array)
+    dyn = jax.tree_map(
+        lambda a, b: jnp.where(jnp.expand_dims(flag, tuple(range(1, a.ndim))), a, b),
+        dyn_a,
+        dyn_b,
+    )
+    return eqx.combine(dyn, static)
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index dbf1085e..0511c545 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -102,6 +102,7 @@ def load_model(self) -> gops.Mutation | gops.Crossover:
 
 @chex.dataclass
 class Log:
+    dead: jax.Array
     parents: jax.Array
     rewards: jax.Array
     age: jax.Array
@@ -144,3 +145,7 @@ def filter_active(self) -> Any:
     def filter_birth(self) -> Any:
         is_birth_event = self.parents > -1
         return jax.tree_map(lambda arr: arr[is_birth_event], self)
+
+    def filter_death(self) -> Any:
+        is_death_event = self.dead > -1
+        return jax.tree_map(lambda arr: arr[is_death_event], self)
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 0935b78e..7f1ba9e5 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -21,17 +21,9 @@ class RewardFn(abc.ABC, eqx.Module):
     def serialize(self) -> dict[str, float | NDArray]:
         pass
 
-    def get_slice(
-        self,
-        slice_idx: int | jax.Array,
-        include_static: bool = False,
-    ) -> Self:
-        dynamic, static = eqx.partition(self, eqx.is_array)
-        sliced_dyn = jax.tree_map(lambda item: item[slice_idx], dynamic)
-        if include_static:
-            return eqx.combine(sliced_dyn, static)
-        else:
-            return sliced_dyn
+    @abc.abstractmethod
+    def __call__(self, *args) -> jax.Array:
+        pass
 
 
 RF = TypeVar("RF", bound=RewardFn)
@@ -83,7 +75,7 @@ def mutate_reward_fn(
     keys = jax.random.split(key, n)
     for key, parent, uid, slot in zip(keys, parents, unique_id, slots):
         parent_reward_fn = reward_fn_dict[parent.item()]
-        mutated_dnet = mutation(key, parent_reward_fn)
+        mutated_dnet = mutation(key, eqx.partition(parent_reward_fn, eqx.is_array)[0])
         reward_fn_dict[uid.item()] = eqx.combine(mutated_dnet, static_net)
         dynamic_net = jax.tree_map(
             lambda orig, mutated: orig.at[slot.item()].set(mutated),
diff --git a/tests/test_config.py b/tests/test_config.py
index 27286be6..8dcaaab8 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -27,7 +27,7 @@ def test_gopsconfig() -> None:
 
     mutation = gopsconfig.load_model()
     assert isinstance(mutation, gops.BernoulliMixtureMutation)
-    assert mutation.mutation_prob == 0.1
+    assert mutation.mutation_prob == 0.2
     assert isinstance(mutation.mutator, gops.UniformMutation)
     assert mutation.mutator.min_noise == -1
     assert mutation.mutator.max_noise == 1
diff --git a/tests/test_reward_fn.py b/tests/test_reward_fn.py
index a27af3fd..bfadf81e 100644
--- a/tests/test_reward_fn.py
+++ b/tests/test_reward_fn.py
@@ -5,6 +5,7 @@
 
 from emevo import genetic_ops as gops
 from emevo.reward_fn import LinearReward, mutate_reward_fn
+from emevo.eqx_utils import get_slice
 
 
 @pytest.fixture
@@ -33,7 +34,7 @@ def test_serialize(reward_fn: LinearReward) -> None:
 
 
 def test_mutation(reward_fn: LinearReward) -> None:
-    reward_fn_dict = {i + 1: reward_fn.get_slice(i) for i in range(5)}
+    reward_fn_dict = {i + 1: get_slice(reward_fn, i) for i in range(5)}
     chex.assert_shape(tuple(map(lambda lr: lr.weight, reward_fn_dict.values())), (3,))
     mutation = gops.GaussianMutation(std_dev=1.0)
     parents = jnp.array([-1, -1, -1, -1, -1, 2, 4, -1, -1, -1])

From 34d4472b1287a3551c0cdb1d7ebda53041196b31 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 22 Dec 2023 12:27:28 +0900
Subject: [PATCH 140/337] Move some functions to outer

---
 experiments/cf_asexual_evo.py | 74 +++++++++++++++++++----------------
 1 file changed, 41 insertions(+), 33 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 43ed97a2..2f76d898 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -190,6 +190,32 @@ def epoch(
     return env_state, obs, log, opt_state, pponet
 
 
+def write_log(logdir: Path, log_list: list[Log], index: int) -> None:
+    log = jax.tree_map(
+        lambda *args: np.array(jnp.concatenate(args, axis=0)),
+        *log_list,
+    )
+    log_dict = dataclasses.asdict(log)
+    pq.write_table(
+        pa.Table.from_pydict(log_dict),
+        logdir.joinpath(f"log-{index}.parquet"),
+        compression="zstd",
+    )
+    log_list.clear()
+
+
+def save_agents(
+    logdir: Path,
+    net: NormalPPONet,
+    unique_id: jax.Array,
+    slots: jax.Array,
+) -> None:
+    for uid, slot in zip(np.array(unique_id), np.array(slots)):
+        sliced_net = get_slice(net, slot)
+        modelpath = logdir.joinpath(f"trained-{uid}.eqx")
+        eqx.tree_serialise_leaves(modelpath, sliced_net)
+
+
 def run_evolution(
     *,
     key: jax.Array,
@@ -228,39 +254,10 @@ def initialize_net(key: chex.PRNGKey) -> NormalPPONet:
     pponet = initialize_net(net_key)
     adam_init, adam_update = adam
 
+    @eqx.filter_jit
     def initialize_opt_state(net: eqx.Module) -> optax.OptState:
         return jax.vmap(adam_init)(eqx.filter(net, eqx.is_array))
 
-    opt_state = initialize_opt_state(pponet)
-    env_state, timestep = env.reset(reset_key)
-    obs = timestep.obs
-
-    if debug_vis:
-        visualizer = env.visualizer(env_state, figsize=(xmax * 2, ymax * 2))
-    else:
-        visualizer = None
-
-    log_list = []
-
-    def write_log(index: int) -> None:
-        log = jax.tree_map(
-            lambda *args: np.array(jnp.concatenate(args, axis=0)),
-            *log_list,
-        )
-        log_dict = dataclasses.asdict(log)
-        pq.write_table(
-            pa.Table.from_pydict(log_dict),
-            logdir.joinpath(f"log-{index}.parquet"),
-            compression="zstd",
-        )
-        log_list.clear()
-
-    def save_agents(unique_id: jax.Array, slots: jax.Array) -> None:
-        for uid, slot in zip(np.array(unique_id), np.array(slots)):
-            network = get_slice(pponet, slot)
-            modelpath = logdir.joinpath(f"trained-{uid}.eqx")
-            eqx.tree_serialise_leaves(modelpath, network)
-
     @eqx.filter_jit
     def replace_net(
         key: chex.PRNGKey,
@@ -281,6 +278,17 @@ def replace_net(
         )
         return pponet, opt_state
 
+    opt_state = initialize_opt_state(pponet)
+    env_state, timestep = env.reset(reset_key)
+    obs = timestep.obs
+
+    if debug_vis:
+        visualizer = env.visualizer(env_state, figsize=(xmax * 2, ymax * 2))
+    else:
+        visualizer = None
+
+    log_list = []
+
     reward_fn_dict = {i + 1: get_slice(reward_fn, i) for i in range(n_initial_agents)}
 
     last_log_index = 0
@@ -315,7 +323,7 @@ def replace_net(
         # Save network
         log_with_step = log.with_step(i * n_rollout_steps)
         log_death = log_with_step.filter_death()
-        save_agents(log_death.dead, log_death.slots)
+        save_agents(logdir, pponet, log_death.dead, log_death.slots)
         log_birth = log_with_step.filter_birth()
         # Initialize network and adam state for new agents
         is_new = jnp.zeros(env.n_max_agents, dtype=bool).at[log_birth.slots].set(True)
@@ -335,7 +343,7 @@ def replace_net(
 
         log_list.append(log_with_step.filter_active())
         if (i + 1) % log_interval == 0:
-            write_log(last_log_index + 1)
+            write_log(logdir, log_list, last_log_index + 1)
             last_log_index += 1
     rfd_serialized = [
         v.serialize() | {"unique_id": k} for k, v in reward_fn_dict.items()
@@ -345,7 +353,7 @@ def replace_net(
         logdir.joinpath(f"rewards.parquet"),
     )
     if len(log_list) > 0:
-        write_log(last_log_index + 1)
+        write_log(logdir, log_list, last_log_index + 1)
 
 
 app = typer.Typer(pretty_exceptions_show_locals=False)

From ace8f8afd5959bd21b254684ee91451ff6d50532 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 22 Dec 2023 15:27:24 +0900
Subject: [PATCH 141/337] Include energy in CFObs

---
 src/emevo/environments/circle_foraging.py | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 801b5dee..a9a58869 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -71,6 +71,7 @@ class CFObs(NamedTuple):
     velocity: jax.Array
     angle: jax.Array
     angular_velocity: jax.Array
+    energy: jax.Array
 
     def as_array(self) -> jax.Array:
         return jnp.concatenate(
@@ -80,6 +81,7 @@ def as_array(self) -> jax.Array:
                 self.velocity,
                 jnp.expand_dims(self.angle, axis=1),
                 jnp.expand_dims(self.angular_velocity, axis=1),
+                jnp.expand_dims(self.energy, axis=1),
             ),
             axis=1,
         )
@@ -614,17 +616,9 @@ def step(
         )
         # Gather sensor obs
         sensor_obs = self._sensor_obs(stated=stated)
-        obs = CFObs(
-            sensor=sensor_obs.reshape(-1, self._n_sensors, 3),
-            collision=collision,
-            angle=stated.circle.p.angle,
-            velocity=stated.circle.v.xy,
-            angular_velocity=stated.circle.v.angle,
-        )
         # energy_delta = food - coef * |force|
         force_norm = jnp.sqrt(f1_raw**2 + f2_raw**2).ravel()
         energy_delta = food_collision - self._force_energy_consumption * force_norm
-        timestep = TimeStep(encount=c2c, obs=obs)
         # Remove and reproduce foods
         key, food_key = jax.random.split(state.key)
         stated, food_num, food_loc = self._remove_and_reproduce_foods(
@@ -638,6 +632,16 @@ def step(
             energy_delta=energy_delta,
             capacity=self._energy_capacity,
         )
+        # Construct obs
+        obs = CFObs(
+            sensor=sensor_obs.reshape(-1, self._n_sensors, 3),
+            collision=collision,
+            angle=stated.circle.p.angle,
+            velocity=stated.circle.v.xy,
+            angular_velocity=stated.circle.v.angle,
+            energy=status.energy,
+        )
+        timestep = TimeStep(encount=c2c, obs=obs)
         state = CFState(
             physics=stated,
             solver=solver,
@@ -756,6 +760,7 @@ def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
             angle=physics.circle.p.angle,
             velocity=physics.circle.v.xy,
             angular_velocity=physics.circle.v.angle,
+            energy=state.status.energy,
         )
         # They shouldn't encount now
         timestep = TimeStep(encount=jnp.zeros((N, N), dtype=bool), obs=obs)

From 7fc9acd8d985ecd47acd3808a91844ec9d6e800f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 22 Dec 2023 15:28:19 +0900
Subject: [PATCH 142/337] Tweak on config

---
 config/bd/20231222-a035-e020-ab001.toml | 14 ++++++++++++++
 config/env/20231214-square.toml         |  2 +-
 notebooks/bd_rate.ipynb                 | 12 ++++++------
 3 files changed, 21 insertions(+), 7 deletions(-)
 create mode 100644 config/bd/20231222-a035-e020-ab001.toml

diff --git a/config/bd/20231222-a035-e020-ab001.toml b/config/bd/20231222-a035-e020-ab001.toml
new file mode 100644
index 00000000..15a5d2b0
--- /dev/null
+++ b/config/bd/20231222-a035-e020-ab001.toml
@@ -0,0 +1,14 @@
+birth_fn = "emevo.birth_and_death.EnergyLogisticBirth"
+hazard_fn = "emevo.birth_and_death.ELGompertzHazard"
+
+[hazard_params]
+alpha = 0.35
+alpha_age = 1e-6
+beta = 3e-5
+scale = 0.1
+e0 = 0.0
+
+[birth_params]
+alpha = 0.01
+scale = 2e-4
+e0 = 20.0
diff --git a/config/env/20231214-square.toml b/config/env/20231214-square.toml
index e4118638..07c7b2cb 100644
--- a/config/env/20231214-square.toml
+++ b/config/env/20231214-square.toml
@@ -20,7 +20,7 @@ linear_damping = 0.8
 angular_damping = 0.6
 max_force = 40.0
 min_force = -20.0
-init_energy = 20.0
+init_energy = 40.0
 energy_capacity = 100.0
 force_energy_consumption = 0.00025
 energy_share_ratio = 0.4
diff --git a/notebooks/bd_rate.ipynb b/notebooks/bd_rate.ipynb
index ed69fb4e..a09a9826 100644
--- a/notebooks/bd_rate.ipynb
+++ b/notebooks/bd_rate.ipynb
@@ -288,7 +288,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "bd4eab399971473ebcf6f115af6035c9",
+       "model_id": "cc04f16e96c8494ba0af4a9f4aa396a1",
        "version_major": 2,
        "version_minor": 0
       },
@@ -303,18 +303,18 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "b9887936ad9c469f859ba4d07230521f",
+       "model_id": "64f42441f5b74acca4635a2e5569aa70",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAlgAAASwCAYAAAAnoTQJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gc1dk28Htme1fvVnGTKy5yZCSDbZptMCQQSkIopoYWQqhvKB+mBExCDQQCJME2JS/gBHgDCSaYamxjwFiSZfViy1a11aXVtpnz/SHPsLPalVbySlqtnt91+QLPzu6eXcnaW8858xyOMcZACCGEEEJChh/vARBCCCGERBoKWIQQQgghIUYBixBCCCEkxChgEUIIIYSEGAUsQgghhJAQo4BFCCGEEBJiFLAIIYQQQkKMAhYhhBBCSIhRwCKEEEIICTEKWIQQQgghIUYBixBCCCEkxChgEUIIIYSEGAUsQgghhJAQo4BFCCGEEBJiFLAIIYQQQkKMAtYEtWnTJkRFRY33MAghhBDiBwUsonDddddh2rRpMBgMiI+Px09+8hOUlZUNep933nkHq1atQmxsLDiOQ0FBgd/zdu3ahVNPPRUmkwlWqxXLly9HX1/fcY/5+eefR2ZmJvR6PZYuXYpvvvlGvq2trQ0333wzsrOzYTAYkJ6ejl//+tfo7Ow87uclhBBCAqGARRRycnKwceNGlJaW4qOPPgJjDKtWrYIgCAHv09vbi5NOOgm///3vA56za9curFmzBqtWrcI333yDb7/9Fr/61a/A88f3LfjWW2/htttuw/r16/H9999jwYIFWL16NVpaWgAADQ0NaGhowBNPPIHi4mJs2rQJW7duxdVXX31cz0sIIYQMipFRs2XLFjZv3jym1+tZTEwMO+2001hPT498+9/+9jc2Z84cptVqWVJSErvpppvk25588kk2b948ZjQaWVpaGrvhhhtYd3e3fPvGjRuZzWZTPN97773HFi1axHQ6HcvKymIPPPAAc7vdx/UaCgsLGQBWVVU15Lm1tbUMANu7d++A25YuXcruu+++Qe9fV1fHLrzwQmaz2Vh0dDT78Y9/zGprawe9T25uruJ9EwSBpaSksA0bNgS8z9tvv820Wu1xvzeEEEJIIFTBGiWNjY24+OKLcdVVV6G0tBSff/45fvrTn4IxBgD485//jJtuugm//OUvsW/fPvzrX//C9OnT5fvzPI9nn30W+/fvx+bNm/Hpp5/irrvuCvh827dvx+WXX45bbrkFJSUleOmll7Bp0yY88sgj8jlXXHEFVq5cGfRr6O3txcaNG5GVlYUpU6YM/004pqWlBbt370ZCQgLy8/ORmJiIFStW4KuvvpLPcbvdWL16NSwWC7Zv344dO3bAbDZjzZo1cLlcfh/X5XJhz549OP300+VjPM/j9NNPx65duwKOp7OzE1arFWq1esSviRBCCBnUeCe8SLVnzx4GgB04cMDv7SkpKezee+8N+vG2bNnCYmNj5b/7VrBOO+009uijjyru89prr7Hk5GT577/97W/ZZZddNuRzPf/888xkMjEALDs7O6jqFWOBK1i7du1iAFhMTAx75ZVX2Pfff89+85vfMK1WyyoqKuSxZmdnM1EU5fs5nU5mMBjYRx995Pf56uvrGQC2c+dOxfE777yT5ebm+r3PkSNHWHp6OrvnnnuCek2EEELISFAFa5QsWLAAp512GubPn48LL7wQf/nLX9De3g6gv6LT0NCA0047LeD9t23bhtNOOw2pqamwWCy47LLL0NraCrvd7vf8wsJCPPTQQzCbzfKfa6+9Fo2NjfJ9NmzYgFdffXXIsV9yySXYu3cvvvjiC8ycORMXXXQRHA7HCN6FfqIoAuhfQH/llVdi0aJFePrpp5GdnY1XXnlFHn9VVRUsFos8/piYGDgcDlRXV2P79u2K1/bGG28MexxdXV1Yu3Yt5syZgwceeGDEr4cQQggZCs2RjBKVSoWPP/4YO3fuxH//+18899xzuPfee7F7927ExcUNet8DBw7g7LPPxg033IBHHnkEMTEx+Oqrr3D11VfD5XLBaDQOuE9PTw8efPBB/PSnPx1wm16vH9bYbTYbbDYbZsyYgRNPPBHR0dF49913cfHFFw/rcSTJyckAgDlz5iiOz549G3V1dfL4c3Jy/Aan+Ph4aLVaxdWJiYmJ0Ol0UKlUaG5uVpzf3NyMpKQkxbHu7m6sWbMGFosF7777LjQazYheCyGEEBIMqmCNIo7jsGzZMjz44IPYu3cvtFot3n33XVgsFmRmZuKTTz7xe789e/ZAFEU8+eSTOPHEEzFz5kw0NDQM+lyLFy9GeXk5pk+fPuDP8VypxxgDYwxOp3PEj5GZmYmUlBSUl5crjldUVCAjI0Mef2VlJRISEgaM32azwWAwKI5ZLBZotVrk5OQo3kdRFPHJJ58gLy9PPtbV1YVVq1ZBq9XiX//617ADJyGEEDJcVMEaJbt378Ynn3yCVatWISEhAbt378aRI0cwe/ZsAMADDzyA66+/HgkJCTjzzDPR3d2NHTt24Oabb8b06dPhdrvx3HPP4ZxzzsGOHTvw4osvDvp8999/P84++2ykp6fjggsuAM/zKCwsRHFxMX73u98BAO6++27U19cHnCasqanBW2+9hVWrViE+Ph6HDx/GY489BoPBgLPOOks+b9asWdiwYQPOO+88AP29purq6uQQKAWppKQkJCUlgeM43HnnnVi/fj0WLFiAhQsXYvPmzSgrK8M//vEPAP3Tko8//jh+8pOf4KGHHkJaWhoOHjyId955B3fddRfS0tL8jvm2227DunXrsGTJEuTm5uKZZ55Bb28vrrzySgA/hCu73Y7XX38dXV1d6OrqAtBfGVOpVEN/MQkhhJDhGu9FYJGqpKSErV69msXHxzOdTsdmzpzJnnvuOcU5L774IsvOzmYajYYlJyezm2++Wb7tqaeeYsnJycxgMLDVq1ezV199lQFg7e3tjDH/bRq2bt3K8vPzmcFgYFarleXm5rKXX35Zvn3dunVsxYoVAcdcX1/PzjzzTJaQkMA0Gg1LS0tjv/jFL1hZWZniPABs48aN8t83btzIAAz4s379esX9NmzYwNLS0pjRaGR5eXls+/btitsbGxvZ5ZdfzuLi4phOp2NTp05l1157Levs7Aw4ZsYYe+6551h6ejrTarUsNzeXff311/Jtn332md+xARiyBQQhhBAyUhxjx/oGEEIIIYSQkKA1WIQQQgghIUYBixBCCCEkxChgEUIIIYSEGAUsQgghhJAQo4BFCCGEEBJiFLDGWV1dHdauXQuj0YiEhATceeed8Hg8w3qMzz//HBzHDfjT1NQ06P2Kiopw8sknQ6/XY8qUKfjDH/4w4JwtW7Zg1qxZ0Ov1mD9/Pv7zn/8Ma2wj8fzzzyMzMxN6vR5Lly7FN998o7jd4XDgpptuQmxsLMxmM84///wB3dwJIYSQ8UQBaxwJgoC1a9fC5XJh586d2Lx5MzZt2oT7779/RI9XXl6OxsZG+U9CQkLAc6UGnBkZGdizZw8ef/xxPPDAA3j55Zflc3bu3ImLL74YV199Nfbu3Ytzzz0X5557LoqLi0c0PgDYtGkTVq5cGfD2t956C7fddhvWr1+P77//HgsWLMDq1avR0tIin3Prrbfi/fffx5YtW/DFF1+goaHB7xZBhBBCyLgZ70ZckUwQBPboo4+yzMxMptfr2QknnMC2bNki3/6f//yH8TzPmpqa5GN//vOfmdVqZU6nM+jnkZppSk1Ig/HCCy+w6OhoxfP8z//8D8vOzpb/ftFFF7G1a9cq7rd06VJ23XXXyX93OBzs9ttvZykpKcxoNLLc3Fz22WefBXzejRs3DtrsNDc3l910003y3wVBYCkpKWzDhg2MMcY6OjqYRqNRvI+lpaUMANu1a9eQr5sQQggZC1TBGkUbNmzAq6++ihdffBH79+/HrbfeiksvvRRffPEFAGDXrl2YP38+EhMT5fusXr0aXV1d2L9/P4D+jZ85jsPnn38+5PMtXLgQycnJOOOMM7Bjx45Bz921axeWL18OrVareO7y8nK0t7fL55x++umK+61evRq7du2S//6rX/0Ku3btwptvvomioiJceOGFWLNmDSorK4ccry+Xy4U9e/YonpPneZx++unyc+7Zswdut1txzqxZs5Cenq4YFyGEEDKeaC/CUeJ0OvHoo49i27Zt8sbDU6dOxVdffYWXXnoJK1asQFNTkyJcAZD/Lq2f0mg0yM7OhtFoDPhcycnJePHFF7FkyRI4nU789a9/xcqVK7F7924sXrzY732ampqQlZUV8Lmjo6MDjk8aW11dHTZu3Ii6ujqkpKQAAO644w5s3boVGzduxKOPPhrUeyU5evQoBEHw+5xlZWXy2LRaLaKiogKOixBCCBlvFLBGSVVVFex2O8444wzFcZfLhUWLFgX9OKmpqXK4CCQ7OxvZ2dny3/Pz81FdXY2nn34ar7322vAGPgz79u2DIAiYOXOm4rjT6URsbCyA/hA2Z84c+TaPxwO32w2z2Swfu+eee3DPPfeM2jgJIYSQsUYBa5T09PQAAP79738jNTVVcZtOpwMAJCUlDbhCTroaLikp6biePzc3F1999VXA25OSkgZceef73IHOkW7v6emBSqXCnj17oFKpFOdJASolJQUFBQXy8XfeeQf//Oc/8cYbb8jHYmJiAABxcXFQqVSDPmdSUhJcLhc6OjoUVSzvcwghhJDxRmuwRsmcOXOg0+lQV1eH6dOnK/5MmTIFAJCXl4d9+/YprpD7+OOPYbVaFVWfkSgoKEBycnLA2/Py8vDll1/C7XYrnjs7OxvR0dHyOZ988onifh9//LE85blo0SIIgoCWlpYBr1EKO2q1WnE8ISEBBoNBcUwKWFqtFjk5OYrnFEURn3zyifycOTk50Gg0inPKy8tRV1cnn0MIIYSMu/FeZR/J7r33XhYbG8s2bdrEqqqq2J49e9izzz7LNm3axBhjzOPxsHnz5rFVq1axgoICtnXrVhYfH8/uvvtu+TEOHz7MsrOz2e7duwM+z9NPP83ee+89VllZyfbt28duueUWxvM827Ztm3zOc889x0499VT57x0dHSwxMZFddtllrLi4mL355pvMaDSyl156ST5nx44dTK1WsyeeeIKVlpay9evXM41Gw/bt2yefc8kll7DMzEz2z3/+k9XU1LDdu3ezRx99lH3wwQd+xzrUVYRvvvkm0+l0bNOmTaykpIT98pe/ZFFRUYorLa+//nqWnp7OPv30U/bdd9+xvLw8lpeXF/AxCSGEkLFGAWsUiaLInnnmGZadnc00Gg2Lj49nq1evZl988YV8zoEDB9iZZ57JDAYDi4uLY7fffjtzu93y7bW1tQzAoK0Pfv/737Np06YxvV7PYmJi2MqVK9mnn36qOGf9+vUsIyNDcaywsJCddNJJTKfTsdTUVPbYY48NeOy3336bzZw5k2m1WjZ37lz273//W3G7y+Vi999/P8vMzGQajYYlJyez8847jxUVFfkd61ABi7H+MJiens60Wi3Lzc1lX3/9teL2vr4+duONN7Lo6GhmNBrZeeedxxobGwd9TEIIIWQscYwxNt5VNEIIIYSQSEJrsAghhBBCQowCFiGEEEJIiFHAIoQQQggJMQpYhBBCCCEhRgGLEEIIISTEKGCNI2kjZ+9O50PZtGnTgH34CCGEEBJeKGCRsHbddddh2rRpMBgMiI+Px09+8pMh92Z85513sGrVKsTGxg4aYHft2oVTTz0VJpMJVqsVy5cvR19f33GP+fnnn0dmZib0ej2WLl06YDuklStXguM4xZ/rr7/+uJ+XEEJI+KCARcJaTk4ONm7ciNLSUnz00UdgjGHVqlUQBCHgfXp7e3HSSSfh97//fcBzdu3ahTVr1mDVqlX45ptv8O233+JXv/oVeP74/km89dZbuO2227B+/Xp8//33WLBgAVavXq3YDgkArr32WjQ2Nsp//vCHPxzX8xJCCAkz49zoNKJ9+OGHbNmyZcxms7GYmBi2du1aVlVVJd8udWnfu3cvY4yxzz77jAFgH3zwAZs/fz7T6XRs6dKliq1pNm7cyGw2G9u6dSubNWsWM5lMbPXq1ayhoUE+55tvvmGnn346i42NZVarlS1fvpzt2bMn6HE/+eSTbN68ecxoNLK0tDR2ww03sO7ubsU5L7/8MktLS2MGg4Gde+657Mknn2Q2m01xznvvvccWLVrEdDody8rKYg888ICiS/1IFBYWMgCK9zEQ3/fX29KlS9l999036P3r6urYhRdeyGw2G4uOjmY//vGPWW1t7aD3yc3NZTfddJP8d0EQWEpKCtuwYYN8bMWKFeyWW24ZcvyEEEImLqpgjaLe3l7cdttt+O677/DJJ5+A53mcd955EEVx0PvdeeedePLJJ/Htt98iPj4e55xzjmJTZrvdjieeeAKvvfYavvzyS9TV1eGOO+6Qb+/u7sa6devw1Vdf4euvv8aMGTNw1llnobu7O6hx8zyPZ599Fvv378fmzZvx6aef4q677pJv37FjB66//nrccsstKCgowBlnnIFHHnlE8Rjbt2/H5ZdfjltuuQUlJSV46aWXsGnTJsV5V1xxBVauXBnUmID+93Pjxo3IysqSN8weiZaWFuzevRsJCQnIz89HYmIiVqxYga+++ko+x+12Y/Xq1bBYLNi+fTt27NgBs9mMNWvWwOVy+X1cl8uFPXv24PTTT5eP8TyP008/Hbt27VKc+8YbbyAuLg7z5s3D3XffDbvdPuLXQwghJAyNd8KbTI4cOcIAyBWpQBWsN998U75Pa2srMxgM7K233mKM9Vew4FPBef7551liYmLA5xUEgVksFvb++++PaNxbtmxhsbGx8t9/9rOfsbVr1yrOueSSSxQVrNNOO409+uijinNee+01lpycLP/9t7/9LbvsssuGfP7nn3+emUwmBoBlZ2cHVb1iLHAFa9euXQwAi4mJYa+88gr7/vvv2W9+8xum1WpZRUWFPNbs7GwmiqJ8P6fTyQwGA/voo4/8Pl99fT0DwHbu3Kk4fuedd7Lc3Fz57y+99BLbunUrKyoqYq+//jpLTU1l5513XlCviRBCyMRAFaxRVFlZiYsvvhhTp06F1WpFZmYmAKCurm7Q++Xl5cn/HxMTg+zsbJSWlsrHjEYjpk2bJv89OTlZscanubkZ1157LWbMmAGbzQar1Yqenp4hn1eybds2nHbaaUhNTYXFYsFll12G1tZWucpSXl6O3NxcxX18/15YWIiHHnoIZrNZ/iOtO5IeZ8OGDXj11VeHHM8ll1yCvXv34osvvsDMmTNx0UUXweFwBPVa/JEqiNdddx2uvPJKLFq0CE8//TSys7PxyiuvyOOvqqqCxWKRxx8TEwOHw4Hq6mps375d8dreeOONoJ//l7/8JVavXo358+fjkksuwauvvop3330X1dXVI35NhBBCwot6vAcQyc455xxkZGTgL3/5C1JSUiCKIubNmxdwiilYGo1G8XeO48C89uxet24dWltb8cc//hEZGRnQ6XTIy8sL6nkPHDiAs88+GzfccAMeeeQRxMTE4KuvvsLVV18Nl8sFo9EY1Bh7enrw4IMP4qc//emA2/R6fVCPIbHZbLDZbJgxYwZOPPFEREdH491338XFF188rMeRJCcnAwDmzJmjOD579mw5hPb09CAnJ8dvcIqPj4dWq1VcnZiYmAidTgeVSoXm5mbF+c3NzUhKSgo4nqVLlwIAqqqqFMGZEELIxEUBa5S0traivLwcf/nLX3DyyScDgGKNz2C+/vprpKenAwDa29tRUVGB2bNnB/3cO3bswAsvvICzzjoLAHDo0CEcPXo0qPvu2bMHoijiySeflK+oe/vttxXnZGdn49tvv1Uc8/374sWLUV5ejunTpwc97mAwxsAYg9PpHPFjZGZmIiUlBeXl5YrjFRUVOPPMMwH0j/+tt95CQkICrFar38fx99pycnLwySef4NxzzwXQXy375JNP8Ktf/SrgeKSgJgU/QgghEx8FrFESHR2N2NhYvPzyy0hOTkZdXR1++9vfBnXfhx56CLGxsUhMTMS9996LuLg4+QM7GDNmzMBrr72GJUuWoKurC3feeScMBkNQ950+fTrcbjeee+45nHPOOdixYwdefPFFxTk333wzli9fjqeeegrnnHMOPv30U3z44YfgOE4+5/7778fZZ5+N9PR0XHDBBeB5HoWFhSguLsbvfvc7AMDdd9+N+vr6gNOENTU1eOutt7Bq1SrEx8fj8OHDeOyxx2AwGOTwCACzZs3Chg0bcN555wEA2traUFdXh4aGBgCQg1RSUhKSkpLAcRzuvPNOrF+/HgsWLMDChQuxefNmlJWV4R//+AeA/mnJxx9/HD/5yU/w0EMPIS0tDQcPHsQ777yDu+66C2lpaX7HfNttt2HdunVYsmQJcnNz8cwzz6C3txdXXnklAKC6uhp///vfcdZZZyE2NhZFRUW49dZbsXz5cpxwwglBfY0IIYRMAOO8Biyiffzxx2z27NlMp9OxE044gX3++ecMAHv33XcZY4EXub///vts7ty5TKvVstzcXFZYWCg/ptSmwdu7777LvL+U33//PVuyZAnT6/VsxowZbMuWLSwjI4M9/fTTQY37qaeeYsnJycxgMLDVq1ezV199lQFg7e3t8jkvv/wyS01Nlds0/O53v2NJSUmKx9m6dSvLz89nBoOBWa1Wlpuby15++WX59nXr1rEVK1YEHEd9fT0788wzWUJCAtNoNCwtLY394he/YGVlZYrzALCNGzcq3iMAA/6sX79ecb8NGzawtLQ0ZjQaWV5eHtu+fbvi9sbGRnb55ZezuLg4ptPp2NSpU9m1117LOjs7B33/nnvuOZaeni5//b7++mv5trq6OrZ8+XIWExPDdDodmz59OrvzzjuHfExCCCETC8eY1+IdMq4+//xznHLKKWhvb59w2+Fce+21KCsrw/bt28d7KIQQQsi4oylCMiJPPPEEzjjjDJhMJnz44YfYvHkzXnjhhfEeFiGEEBIWqE3DJPPGG28o2gt4/5k7d27Qj/PNN9/gjDPOwPz58/Hiiy/i2WefxTXXXDOKIyeEEEImDpoinGS6u7sHtBGQaDQaZGRkjPGICCGEkMhDAYsQQgghJMRoinAUrVy5Er/5zW/GexiEEEIIGWMUsMLcpk2bRvWKwl//+tfIycmBTqfDwoULg7qPw+HATTfdhNjYWJjNZpx//vkDph3r6uqwdu1aGI1GJCQk4M4774TH4znu8ba1teGSSy6B1WpFVFQUrr76avT09Pg9V9rqZqJdkUkIIWTio4BFcNVVV+FnP/tZ0OffeuuteP/997FlyxZ88cUXaGhoUGyJIwgC1q5dC5fLhZ07d2Lz5s3YtGkT7r///uMe6yWXXIL9+/fj448/xgcffIAvv/wSv/zlLwec53a7cfHFF8td9AkhhJAxNZ5NuCLdihUr2E033cRuuukmZrVaWWxsLLvvvvuYKIryOQ6Hg91+++0sJSWFGY1Glpubyz777DPG2A+NR+GnWearr77KcnJymNlsZomJieziiy9mzc3NIx7r+vXr2YIFC4Y8r6Ojg2k0GrZlyxb5WGlpKQPAdu3axRhj7D//+Q/jeZ41NTXJ5/z5z39mVquVOZ1O+dh7773HFi1axHQ6HcvKymIPPPAAc7vdAZ+7pKSEAWDffvutfOzDDz9kHMex+vp6xbl33XUXu/TSS/02ZiWEEEJGG1WwRtnmzZuhVqvxzTff4I9//COeeuop/PWvf5Vv/9WvfoVdu3bhzTffRFFRES688EKsWbMGlZWVyM/PxzPPPAOr1YrGxkY0NjbijjvuANBfoXn44YdRWFiI9957DwcOHMAVV1yheO7MzEw88MADIX09e/bsgdvtxumnny4fmzVrFtLT07Fr1y4AwK5duzB//nwkJibK56xevRpdXV3Yv38/AGD79u24/PLLccstt6CkpAQvvfQSNm3ahEceeSTgc+/atQtRUVFYsmSJfOz0008Hz/PYvXu3fOzTTz/Fli1b8Pzzz4fsdRNCCCHDQY1GR9mUKVPw9NNPg+M4ZGdnY9++fXj66adx7bXXoq6uDhs3bkRdXR1SUlIAAHfccQe2bt2KjRs34tFHH4XNZgPHcUhKSlI87lVXXSX//9SpU/Hss8/iRz/6EXp6emA2mwEA06ZNQ1xcXEhfT1NTE7Ra7YB1TYmJiWhqapLP8Q5X0u3SbQDw4IMP4re//S3WrVsnv4aHH34Yd911F9avXx/wuRMSEhTH1Go1YmJi5MdtbW3FFVdcgddffz3gJs2EEELIaKOANcpOPPFExSbIeXl5ePLJJyEIAvbt2wdBEDBz5kzFfZxOJ2JjYwd93D179uCBBx5AYWEh2tvbIYoigP7F5XPmzAEAfPLJJyF+NaFTWFiIHTt2KCpWgiDA4XDAbrfjtttuw+uvvy7fFmghu69rr70Wv/jFL7B8+fKQj5kQQggJFgWscdTT0wOVSoU9e/ZApVIpbpOqUP709vZi9erVWL16Nd544w3Ex8ejrq4Oq1evhsvlGtUxJyUlweVyoaOjQ1HFam5ulqtsSUlJ+OabbxT3k64ylM7p6enBgw8+qFgcL9Hr9XjooYfk6VDv525paVEc83g8aGtrkx/3008/xb/+9S888cQTAADGGERRhFqtxssvv6yo/BFCCCGjhQLWKPNeGwQAX3/9NWbMmAGVSoVFixZBEAS0tLQEvNpNq9VCEATFsbKyMrS2tuKxxx7DlClTAADffffd6LwAHzk5OdBoNPjkk09w/vnnAwDKy8tRV1eHvLw8AP1VukceeQQtLS3ylN7HH38Mq9UqV9cWL16M8vJyTJ8+3e/zJCQkDJgOzMvLQ0dHB/bs2YOcnBwA/YFKFEUsXboUQP86Le/36//+7//w+9//Hjt37kRqamoI3wlCCCFkEOO9yj6SrVixgpnNZnbrrbeysrIy9ve//52ZTCb24osvyudccsklLDMzk/3zn/9kNTU1bPfu3ezRRx9lH3zwAWOMsR07djAAbNu2bezIkSOst7eXtbS0MK1Wy+68805WXV3N/u///o/NnDmTAWB79+6VH/vUU09lzz333KBjrKysZHv37mXXXXcdmzlzJtu7dy/bu3evfLXf4cOHWXZ2Ntu9e7d8n+uvv56lp6ezTz/9lH333XcsLy+P5eXlybd7PB42b948tmrVKlZQUMC2bt3K4uPj2d133y2fs3XrVqZWq9kDDzzAiouLWUlJCfvf//1fdu+99w463jVr1rBFixax3bt3s6+++orNmDGDXXzxxQHPp6sICSGEjAcKWKNoxYoV7MYbb2TXX389s1qtLDo6mt1zzz2KNg0ul4vdf//9LDMzk2k0GpacnMzOO+88VlRUJJ9z/fXXs9jYWEWbhr///e8sMzOT6XQ6lpeXx/71r38NCFgZGRny+YONET6tIACw2tpaxhhjtbW1DIDcOoIxxvr6+tiNN97IoqOjmdFoZOeddx5rbGxUPO6BAwfYmWeeyQwGA4uLi2O33377gBYMW7duZfn5+cxgMDCr1cpyc3PZyy+/POh4W1tb2cUXX8zMZjOzWq3syiuvZN3d3QHPp4BFCCFkPNBehIQQQgghIUZ9sAghhBBCQowCFiGEEEJIiFHAIoQQQggJMQpYhBBCCCEhRgGLEEIIISTEKGARQgghhIQYBSxCCCGEkBCjgEUIIYQQEmIUsAghhBBCQowCFiGEEEJIiFHAIoQQQggJMQpYhBBCCCEhRgGLEEIIISTEKGARQgghhIQYBSxCCCGEkBCjgEUIIYQQEmIUsAghhBBCQowCFiGEEEJIiFHAIoQQQggJMQpYhBBCCCEhRgGLEEIIISTEKGARQgghhIQYBSxCCCGEkBCjgEUIIYQQEmIUsAghhBBCQowCFiGEEEJIiFHAIoQQQggJMQpYhBBCCCEhRgGLEEIIISTEKGARQgghhIQYBSxCCCGEkBCjgEUIIYQQEmIUsAghhBBCQowCFiGEEEJIiFHAIoQQQggJMQpYhBBCCCEhRgGLEEIIISTEKGARQgghhIQYBSxCCCGEkBCjgEUIIYQQEmIUsAghhBBCQowCFiGEEEJIiFHAIoQQQggJMQpYhBBCCCEhRgGLEEIIISTEKGARQiaVK664ApmZmUOel5mZibPPPnv0BzRGVq5ciZUrVw55nsfjwV133YUpU6aA53mce+65oz62kdi0aRM4jsOBAwfGeyiE+EUBi4w76QdloD9ff/21fC7HcfjVr34V1OO+//77OOecc5CYmAitVouYmBgsX74cTz75JLq6ukbr5YSVRx99FO+9996I7nvFFVfAbDYHvH04Xwsycbzyyit4/PHHccEFF2Dz5s249dZbx3U8x/M9TMh4Uo/3AAiRPPTQQ8jKyhpwfPr06cN6HFEUcfXVV2PTpk2YP38+brzxRkyZMgXd3d3YtWsX7rvvPvznP//BJ598Eqqhh61HH30UF1xwQdhWIUj4+fTTT5Gamoqnn356vIcCIPD38GWXXYaf//zn0Ol04zMwQoZAAYuEjTPPPBNLliw57sf5wx/+gE2bNuHWW2/Fk08+CY7j5NtuueUWNDY24tVXXz3u5wlXjDE4HA4YDIbxHsq4cDgc0Gq14PnJVaDv7e2FyWQ67sdpaWlBVFTU8Q9olKlUKqhUqvEeBiEBTa6fQCTi2e12/P73v8fcuXPx+OOPK8KVJDk5Gf/zP/+jOObxePDwww9j2rRp0Ol0yMzMxD333AOn06k4T1qX8/nnn2PJkiUwGAyYP38+Pv/8cwDAO++8g/nz50Ov1yMnJwd79+5V3F+adqupqcHq1athMpmQkpKChx56CIwxxbmiKOKZZ57B3LlzodfrkZiYiOuuuw7t7e1+x/TRRx/JY3rppZfAcRx6e3uxefNmebr1iiuuwIEDBwadkh0pl8uF+++/Hzk5ObDZbDCZTDj55JPx2WefKc5buXJlwOfetGkTAKCtrQ133HEH5s+fD7PZDKvVijPPPBOFhYWKx/r888/BcRzefPNN3HfffUhNTYXRaJSngN977z3MmzcPer0e8+bNw7vvvjvs1/XVV18hNzcXer0eU6dOHRDOgx1rZmZmwNctff8cPHgQN954I7Kzs2EwGBAbG4sLL7xwwDojaVr9iy++wI033oiEhASkpaXJt7/88suYNm0aDAYDcnNzsX379iFfp/R98dlnn2H//v2KsUnvszRO3/tIXzfgh+/x+vp6nHvuuTCbzYiPj8cdd9wBQRAU9xdFEX/84x/lfzPx8fFYs2YNvvvuOwAI+D3s/R74vjcvvPAC5s6dC51Oh5SUFNx0003o6OhQnLNy5UrMmzcPJSUlOOWUU2A0GpGamoo//OEPQ75PhASLKlgkbHR2duLo0aOKYxzHITY2NujH+Oqrr9DR0YE77rhjWL/dXnPNNdi8eTMuuOAC3H777di9ezc2bNiA0tLSAR/KVVVV+MUvfoHrrrsOl156KZ544gmcc845ePHFF3HPPffgxhtvBABs2LABF110EcrLyxXVFEEQsGbNGpx44on4wx/+gK1bt2L9+vXweDx46KGH5POuu+46bNq0CVdeeSV+/etfo7a2Fn/605+wd+9e7NixAxqNRj63vLwcF198Ma677jpce+21yM7OxmuvvYZrrrkGubm5+OUvfwkAmDZtGuLj4/Haa68pXpPb7catt94KrVY74L3x/ZoE0tXVhb/+9a+4+OKLce2116K7uxt/+9vfsHr1anzzzTdYuHAhAODee+/FNddco7jv66+/jo8++ggJCQkAgJqaGrz33nu48MILkZWVhebmZrz00ktYsWIFSkpKkJKSorj/ww8/DK1WizvuuANOpxNarRb//e9/cf7552POnDnYsGEDWltbceWVVyqCyFCqqqpwwQUX4Oqrr8a6devwyiuv4IorrkBOTg7mzp07rLE+88wz6OnpUTz+008/jYKCAvl7/Ntvv8XOnTvx85//HGlpaThw4AD+/Oc/Y+XKlSgpKYHRaFTc/8Ybb0R8fDzuv/9+9Pb2AgD+9re/4brrrkN+fj5+85vfoKamBj/+8Y8RExODKVOmBHyt0vfFI488gp6eHmzYsAEAMHv2bJSWlgb9ngH93+OrV6/G0qVL8cQTT2Dbtm148sknMW3aNNxwww3yedJU/plnnolrrrkGHo8H27dvx9dff40lS5YE/B4O5IEHHsCDDz6I008/HTfccAPKy8vx5z//Gd9+++2AfzPt7e1Ys2YNfvrTn+Kiiy7CP/7xD/zP//wP5s+fjzPPPHNYr5cQvxgh42zjxo0MgN8/Op1OcS4AdtNNNwV8rD/+8Y8MAHvvvfcUxz0eDzty5IjijyiKjDHGCgoKGAB2zTXXKO5zxx13MADs008/lY9lZGQwAGznzp3ysY8++ogBYAaDgR08eFA+/tJLLzEA7LPPPpOPrVu3jgFgN998s3xMFEW2du1aptVq2ZEjRxhjjG3fvp0BYG+88YZiTFu3bh1wXBrT1q1bB7wfJpOJrVu3LuD7JbnxxhuZSqVSvFZprIP98f5aeDwe5nQ6FY/b3t7OEhMT2VVXXRXwuXfs2ME0Go3iHIfDwQRBUJxXW1vLdDode+ihh+Rjn332GQPApk6dyux2u+L8hQsXsuTkZNbR0SEf++9//8sAsIyMjCHfE+l9/fLLL+VjLS0tTKfTsdtvv33YY/X19ttvMwCKc3xfA2OM7dq1iwFgr776qnxM+jdz0kknMY/HIx93uVwsISGBLVy4UPG1ePnllxkAtmLFiiFf94oVK9jcuXMVx6T32ft7WXqdANjGjRvlY9L3je9rX7RoEcvJyZH//umnnzIA7Ne//vWAMUj/NhkL/D0svQe1tbWMsf6vjVarZatWrVJ8Pf70pz8xAOyVV15RvEbf99TpdLKkpCR2/vnnD3xTCBkBmiIkYeP555/Hxx9/rPjz4YcfDusxpKkh36vf9u3bh/j4eMWf1tZWAMB//vMfAMBtt92muM/tt98OAPj3v/+tOD5nzhzk5eXJf1+6dCkA4NRTT0V6evqA4zU1NQPG6X31nXQ1nsvlwrZt2wAAW7Zsgc1mwxlnnIGjR4/Kf3JycmA2mwdMu2VlZWH16tWDvjeBvPrqq3jhhRfwhz/8AaeccoriNr1eP+BrIv3xpVKp5AqYKIpoa2uDx+PBkiVL8P333/t97qamJlxwwQVYuHAhXnjhBfm4TqeTq36CIKC1tRVmsxnZ2dl+H2vdunWKNWeNjY0oKCjAunXrYLPZ5ONnnHEG5syZE/R7M2fOHJx88sny3+Pj45Gdna34mg53rABQUlKCq666Cj/5yU9w3333yce9X4Pb7UZrayumT5+OqKgov4917bXXKiq13333HVpaWnD99dcrqpFXXHGF4n0YC9dff73i7yeffLLiffvnP/8JjuOwfv36AfcdyVT1tm3b4HK58Jvf/EZRMb722mthtVoH/Ds2m8249NJL5b9rtVrk5ub6/fdKyEjQFCEJG7m5uce9yN1isQDAgKmY6dOny6Hg1VdfVUyRHTx4EDzPD7haMSkpCVFRUTh48KDiuHeIAiB/cPlOv0jHfddM8TyPqVOnKo7NnDkTAOT1JJWVlejs7JSnzHy1tLQo/u7v6stgFBQU4Prrr8fFF188IGAC/aHp9NNPD/rxNm/ejCeffBJlZWVwu92Djs/j8eCiiy6CIAh45513FFeDSWtzXnjhBdTW1irW7vibMvZ9fOlrNmPGjAHnDhZ8fPl+rQEgOjpa8TUd7li7urrw05/+FKmpqXj11VcVYaKvrw8bNmzAxo0bUV9fr1iX19nZOeCxgn3dGo1mwPfcaJLWU3nzfd+qq6uRkpKCmJiYkDyn9Nqzs7MVx7VaLaZOnTrg33FaWtqAIBcdHY2ioqKQjIcQClgkosyaNQsAUFxcjJ/85CfycbPZLAeFr776yu99g/2tOdDarkDHmc/i9WCIooiEhAS88cYbfm/3/fAayRWD7e3tOP/88zFz5kz89a9/Hfb9fb3++uu44oorcO655+LOO+9EQkICVCoVNmzYgOrq6gHn33nnndi1axe2bds2YF3Uo48+iv/3//4frrrqKjz88MOIiYkBz/P4zW9+A1EUBzzWaF0xGczXdLhjveKKK9DQ0IBvvvkGVqtVcdvNN9+MjRs34je/+Q3y8vJgs9nAcRx+/vOfj+nr9hXo34bvonXJRLi6L5T/XgnxhwIWiSgnn3wybDYb3nzzTdx9991BXaqfkZEBURRRWVmJ2bNny8ebm5vR0dGBjIyMkI5RFEXU1NTIVSsAqKioAAC5w/i0adOwbds2LFu27Lg+RAN9MIqiiEsuuQQdHR3Ytm3bgMXTI/GPf/wDU6dOxTvvvKN4Xn9TQG+++SaeeeYZPPPMM1ixYoXfxzrllFPwt7/9TXG8o6MDcXFxQ45F+ppVVlYOuK28vHzI+w/HcMb62GOP4b333sM777wj/zLg+1jr1q3Dk08+KR9zOBwDroILxPt1n3rqqfJxt9uN2tpaLFiwINiXpRAdHQ0AA8bhWxUajmnTpuGjjz5CW1vboFWsYH/xkV57eXm5olrncrlQW1s7rEosIaFAa7BIRDEajbjrrrtQXFyM3/72t35/G/U9dtZZZwHov8rL21NPPQUAWLt2bcjH+ac//Ukxnj/96U/QaDQ47bTTAECeOnv44YcH3Nfj8QT9gWsymfye++CDD+Kjjz7C//7v/454etGXVBHwfn93796NXbt2Kc4rLi7GNddcg0svvRS33HJLwMfy/Tpt2bIF9fX1QY0lOTkZCxcuxObNmxVTax9//DFKSkqCeoxgBTvWbdu24b777sO9994bsPGrv8d67rnnAlaKfC1ZsgTx8fF48cUX4XK55OObNm0K+nvGn4yMDKhUKnz55ZeK497r5obr/PPPB2MMDz744IDbvN+DQN/Dvk4//XRotVo8++yzivv/7W9/Q2dn56j8OyZkMFTBImHjww8/RFlZ2YDj+fn5it9Iv/vuO/zud78bcN7KlStx0kkn4be//S1KS0vx+OOPy5fqp6Wlob29Hd9//z22bNmChIQE6PV6AMCCBQuwbt06vPzyy+jo6MCKFSvwzTffYPPmzTj33HMHLPw+Xnq9Hlu3bsW6deuwdOlSfPjhh/j3v/+Ne+65R576W7FiBa677jps2LABBQUFWLVqFTQaDSorK7Flyxb88Y9/xAUXXDDkc+Xk5GDbtm146qmnkJKSgqysLBiNRjz88MNYvnw5Wlpa8Prrryvu473wdzjOPvtsvPPOOzjvvPOwdu1a1NbW4sUXX8ScOXMUa+KuvPJKAMDy5csHPLf0tT777LPx0EMP4corr0R+fj727duHN954Y1jriDZs2IC1a9fipJNOwlVXXYW2tjY899xzmDt37oA1escj2LFefPHFiI+Px4wZMwa87jPOOAOJiYk4++yz8dprr8Fms2HOnDnyFGqwrUo0Gg1+97vf4brrrsOpp56Kn/3sZ6itrcXGjRuPaw2WzWbDhRdeiOeeew4cx2HatGn44IMPBqwFHI5TTjkFl112GZ599llUVlZizZo1EEUR27dvxymnnCJfCOLve1i6gMRbfHw87r77bjz44INYs2YNfvzjH6O8vBwvvPACfvSjH434+5qQERuPSxcJ8TZYmwb4XAI+2HkPP/yw4nHfffdddtZZZ7H4+HimVqtZVFQUO+mkk9jjjz+uuHSfMcbcbjd78MEHWVZWFtNoNGzKlCns7rvvZg6HQ3FeRkYGW7t27YDXAD/tI6RL2B9//HH52Lp165jJZGLV1dVs1apVzGg0ssTERLZ+/foBl/oz1n95fU5ODjMYDMxisbD58+ezu+66izU0NAw5JsYYKysrY8uXL2cGg4EBYOvWrZMvuQ/0x3esgfi+ZlEU2aOPPsoyMjKYTqdjixYtYh988AFbt26doi2C1P5gsK+1w+Fgt99+O0tOTmYGg4EtW7aM7dq1i61YsULRakB6LVu2bPE7xn/+859s9uzZTKfTsTlz5rB33nlnwHgCCfS++o4h2LEO9p5L7Q/a29vZlVdeyeLi4pjZbGarV69mZWVlLCMjQ9GqQPo38+233/od+wsvvMCysrKYTqdjS5YsYV9++eWA8QTir00DY4wdOXKEnX/++cxoNLLo6Gh23XXXseLiYr9tGvx936xfv17x/cVYf2uPxx9/nM2aNYtptVoWHx/PzjzzTLZnzx75HH/fw97vgdSmQfKnP/2JzZo1i2k0GpaYmMhuuOEG1t7eHtRrDPZ7g5BgcIzRij5CxsoVV1yBf/zjHyGtoBBCCAk/tAaLEEIIISTEKGARQgghhIQYBSxCCCGEkBCjNViEEEIIISFGFSxCCCGEkBCjgEUIIYQQEmIUsAghhBBCQowCFiGEEEJIiFHAIoQQQggJMQpYhBBCCCEhRgGLEEIIISTEKGARQgghhIQYBSxCCCGEkBCjgEUIIYQQEmIUsAghhBBCQowCFiGEEEJIiFHAIoQQQggJMQpYhBBCCCEhRgGLEEIIISTEKGARQgghhIQYBSxCCCGEkBCjgEUIIYQQEmIUsAghhBBCQowCFiGEEEJIiFHAIoQQQggJMQpYhBBCCCEhRgGLEEIIISTEKGARQgghhIQYBSxCCCGEkBCjgEUIIYQQEmIUsAghhBBCQowCFiGEEEJIiFHAIoQQQggJMQpYhBBCCCEhRgGLEEIIISTEKGARQgghhIQYBSxCCCGEkBCjgEUIIYQQEmIUsAghgxJFEYyx8R4GIYRMKOrxHgAhJHyJooje3l54PB5oNBqo1Wqo1WqoVCpwHDfewyOEkLBFAYsQMgBjDIIgwO12QxAECIIAAHC5XBAEAe3t7UhJSYFGo4FKpaLARQghPihgEUIUGGPo7OxEfX09pk6dKh9Xq/t/XLhcLpSVlSE+Ph4ulwscx4HneahUKgpchBByDAUsQohMqlrZ7XYcPnwY06dPH3AOz/cv3VSr1fLaLFEU4Xa7FYHLezqRAhchZLKhgEUIAWMMHo8HHo8HQH+IGmxhu3SbFJpUKpXiuCiKcLlccDqdFLgIIZMSBSxCJjmp+iSKIgDIgcg3REmkvzPGAt7mL3A5nU64XC4AoMBFCIl4FLAImaQYY4pwxfO8HHI4jgtYwRpOEPIOXCqVCowx+Y/T6VRUuKT1W2q1WjEWQgiZiChgETIJMcbkKwQBDAg0vgHL9zbpMYYbgjiOU4Qu78DlcDjkc6TAJVW4KHARQiYaCliETDJS1UoQhEGDy1DNRUPRfDTYwCVVtihwEUImCgpYhEwSUm8rj8czYErQl3cFK9A6q9EQKHCJokiBixAyoVDAImQSGGpK0Fcwa7DGYvucYAIXz/MDFs1T4CKEjDcKWIREOKm31VBVK2/e57S1taGtrQ2xsbGw2Wzy8fHYnzBQ4JK6zQdaNO99P0IIGQsUsAiJUN69rRhjw6rqSBWssrIyHDp0CFFRUWhpaYHb7YbFYgEAdHZ2IiYmRm48Oh6k4CSNwTtweTwe+XbfKUUKXISQ0UYBi5AIJIoiPB5P0FOCvqTpt9bWVixZsgRqtRparRZ9fX1oa2tDZ2cnSktLIQgCoqKiEB0djejoaJjN5rAMXB6PB263O2DgGs8xE0IiEwUsQiKId28rqY3CcCs1TU1NKC4uBgDk5ubKXdk5joPRaIRer0dFRQV+9KMfwePxoL29He3t7Th48CAYYwMC13hWiihwEULGCwUsQiKE70L24YYrQRBQVlaGxsZGzJ49G/v27QPP83KHd4l3M1Kz2Qyz2YwpU6aAMYaenh45cNXW1oLneUXgMhqNYRu4Wlpa0N7ejunTp8tBiwIXIWSkKGAREgGC7W0VSE9PDwoKCqBWq7Fs2bIBW914C3QVIcdxsFgssFgsSE9PhyiK6O7uRnt7O44cOYKqqiqo1WpER0fLoctgMIRN4BIEAb29veA4Tt64GvhhWx8KXISQ4aCARcgENpzeVoHuX19fj9LSUqSnp2PGjBngeR5ut1u+fbD7DobnedhsNthsNmRmZkIURXR2dqK9vR3Nzc2oqKiAVquVq1vR0dHQ6/VBj300SGHLu8IlhVdpmpTjOMV0onSVIiGEeKOARcgENdzeVr48Hg/279+P1tZWLFq0CHFxcfJtQ/W6GqxPViA8z8tBCuifkpQCV319PcrKyqDX6xWBS6vVDus5jkegap1UzZPOkQKXFEIpcBFC/KGARcgEJC08H0nVCuhvsVBYWAiDwYBly5ZBp9Mpbh/q8UIRIFQqFWJiYhATEwOgP/B1dHTIC+b3798Pk8mkWMOl0WiO+3mPx2CBS6pw8TwPlUol9+GS2kIQQiYXCliETCDSlKB0leBIpgQPHjyIyspKTJ06FVOnTvV7/2A2dA51o1G1Wo24uDi5kuZ2u+XAVVtbi+LiYpjNZjlsRUVFQa0e3x9hFLgIIYFQwCJkgjje3lYulwvFxcXo6urCkiVL5Kk6f4YKWCOZIhwujUaD+Ph4xMfHA+gfv3SFYmVlJRwOBywWixy2oqKiFGFnPHgHLun98Re4vKcUKXAREpkoYBES5kLR26qtrQ1FRUWwWq3Iz88Pem3TUPsRjiWtVovExEQkJiYC6G+GKgWusrIyuFwuWK1WucJltVqHHbhC+bq8t/QBlIHL5XIptvWhwEVI5KGARUgY897uBhh+byvGGGpqalBTU4OZM2ciPT096L0Ih6pSjcdehN70ej2Sk5ORnJwMxpgicDU0NMDj8cBms8mBy2KxDNpeYbRfz2CBy+l0DmgLQYGLkImNAhYhYUqqWkmNPofbe8nhcKCoqAgOhwNLly6F1Wod9hhCeRXhaOI4DgaDAQaDASkpKWCMwW63y4Hr0KFDEEVRnkqUAtd49+ACIIcoqekpY2xA4PLeuHokFzUQQsYeBSxCwszx9rYCgCNHjmDfvn2Ii4vD4sWLR7QYfLAQFe4f8BzHwWQywWQyIS0tDYwx9Pb2Krb1AaC4QnG8A6N3ddI3cEl7Q0pTihqNRtH0NNy/HoRMRhSwCAkjUm+rgoICTJs2DSaTaVgfnqIoorKyEnV1dZgzZw5SU1NHPJZwnyIcDn/b+khd5ltbW1FTUwOgP9gcPnw4rLb1kcZFgYuQiYUCFiFhwnu7m9bWVmRkZAzrg9Jut6OwsBCiKCIvLw9ms/m4xjPYc4fbFOFwcRwHq9UKq9WKjIwMiKKImpoaHDlyZMC2PtIfg8Ew7mMOJnD527iaAhchY48CFiHjzF9vK57nhxVgmpqaUFxcjOTkZMyaNSsk7Qp8Q5R3y4aJHrB88TwPg8EAo9GIBQsWQBAEdHV1ob29HY2NjSgvL4dOp1MELt/mrGMtUOASRVEOXNL3EgUuQsYeBSxCxlGg7W44jpMXtw9GEASUlZWhsbER8+bNQ1JSUsjG5h2ipA/vSP5g9g6MKpVKsa2Px+ORt/U5dOgQSkpKYDQaFWu4xnJbH38CBS5BENDW1obGxkbMnj2bAhchY4QCFiHjRKpa+VvIHkwFq6enB4WFheB5Hvn5+TAajSEd31CL3COpgjUUtVqN2NhYxMbGAgi8rY93l/lw2NZHWqMliiLsdjs4joMgCBAEQe7DJU0peu+jSIGLkONHAYuQMebb28pfBWGwChZjDPX19SgtLUV6ejpmzJgx7BYOwZBC1Hh1cg9nvtv6uFwuOXBVV1fDbrcP6DI/ntv6eE89S98rUoXL4/HA7XbLwcp3DRcFLkJGhgIWIWPIt7dVoA+vQBUsj8eDkpISHD16FAsXLpS3kRktE7VNw0iN9HVptVokJCQgISEBAOB0OgNu6xMdHQ2bzTam2/r4C8reFS7pnGAC12iEeUIiEQUsQsaA93Y3wfS28lch6urqQkFBAQwGA/Lz86HX60d1zJHUpmGs6XQ6JCUlyWvivLvMl5aWwuVyyV3mo6KiYLPZRjW4BLN+LtjA5T2dSIGLkMAoYBEyygItZB+MtG5Gun9dXR0qKiowdepUTJ06dUwqSDRFGDq+2/r09fXJgevw4cMQBGFY2/oM10guUAgUuKSNq4EftvWhwEXIQBSwCBlF3r2thnO1lrQGy+Vyobi4GF1dXViyZIl8VdtY8A5R/qaXIs1YBUaO42A0GmE0GpGamjpgW5+6ujowxhRXKJrN5uN6z0VRPO6v2VCBy7vC5b2PIgUuMllRwCJkFBzvdjccx6G3txc7d+6E1WpFfn7+mLcBGGq8VMEKDX/b+vT09MiBq7a2FhzHydOJ0dHRw+7wPxotNvwFLukXCrfbLZ/jHbikqxQJmQwoYBESYiOZEvS9f19fH9ra2pCdnT3sju6hMhnbNITDhz/HcbBYLLBYLEhPT4coivK2PkePHkV1dbWiT5fUZX6wsY9FDzNpQbz3c0qBS6pw8Tzv9ypFQiIRBSxCQmiw3lbBcDqdKCoqgtPpREZGBjIzM0dnoEGYyJs9RxKe52Gz2WCz2ZCZmQlRFOUu883NzaioqIBWq1X04PLd1mc8msQOJ3BpNBp5SpG+t0ikoIBFSAh497aSeg4N94Pi6NGjKCoqkhtajvdWLMDg04CRWMGaCHiel3trZWVlQRAEuct8fX09ysrKBmzrEw5d+IMNXL5ruMZ73ISMFAUsQo6TKIrweDwjnhIURRGVlZWoq6vD7NmzkZqaiqKioqC2yhlNk3GKcCJSqVSIiYlBTEwMAP/b+mg0GqjVarS0tCAqKmrct/UBlIFL+l6SLuyQusxT4CITGQUsQkbI+zdwqUIw3B/+fX19KCwshMfjQV5eHsxmM4DgtsoZbZNtinC83+9Q8d3Wx+12o7y8HD09PaitrUVvby/MZrOiy3w4bOsDgAIXiSgUsAgZAd+F7CMJV01NTSguLkZycjJmzZqlmD4JdrPn0TRYHywgcgJJpNNoNDAajVCpVJg9e/ag2/pIXebHc1sfwH/gkv44nU5FHy5p/ZZaraaNq0lYoYBFyDCNtLeVRBAElJeXo6GhAfPmzZO7fXubCBWs8R7faIjUD2dpXSAw+LY+5eXlcDqdsFqtcuCyWq1juq2PP96/wKhUKkXgcjgcAIDGxkbExcXBYrEomp5G6teUhD8KWIQE6Xh7WwFAT08PCgsLwfM88vPzYTQa/Z4XLhUsb96Bij60JpbBKpG+2/p4d5lvaGiAx+MZELjGu3mov8B16NAhmM1mebpTmlKU1p9R4CJjjQIWIUE43t5WAFBfX4+SkhKkp6djxowZg35I8TwvP9d4mYwVrEg1nKsIDQYDDAYDUlJSAm7r49tlPhwClyiK0Gg00Gg0fitcgTaupsBFRgsFLEKGIC20HWnVyuPxoKSkBEeOHMHChQsRHx8/5H3CpYJFbRoig/cU4XD429ant7dXDlwHDx4EY0zRZf54t/UZKenfpzRuf1OKoihS4CJjhgIWIQFIU4LSVYIj+eHb1dWFgoIC6PV6LFu2DHq9Pqj7hUuFiK4ijAyh6oPFcRzMZjPMZjOmTJkCxhi6u7vlRfO1tbVyny6pwmU0Gsfk+8U7YPkbd6DA5XQ64XA4wPP8gKsUKXCR40EBixA/QrHdTV1dHSoqKpCVlYVp06YN6/60yJ2EUig2e/aH4zhYrVZYrdYB2/ocOXIEVVVVUKvVA7rMh3osUmAKtkrne9WvdH9BECAIgtwWQqpwee+jSIGLBIsCFiFeQtHbyu12o7i4GB0dHcjJyZEbQA4HTRGOj0j98ByrTu7+tvWRmp42NjaivLxcsa1PdHR00FXdwUj/Vka6FszfxtXS7gxut1u+3d8+ipH6PUOOHwUsQo7x3u4GGFlvq/b2dhQWFsJisWDZsmUj7pgdLhWswW4b7/GR4I3XVjk8z8tBCoDfbX30er0icI3k38zxBixfIw1c473Yn4QXCliE4IeF7Dt37sTixYsHbJY7FMYYampqUFNTgxkzZiAjI+O4PtDCpYIVaAyR+Ft7JAfGcNiLEPC/rY+0fuvgwYPYv38/TCaTYtF8MF3mpe/T0XqNFLjISFDAIpOa95SgKIro6ekZdrBxOp0oKipCX18fcnNzYbPZjntc4VTBok7uE1+4BCxfarUacXFxiIuLA9A/vd7e3o6Ojg7U1taiuLhY3tZHCl3+usxLa8zGKtAMFbgAyAvmvddxUeCaXChgkUnL30J2nueHFbCOHj2KoqIixMbGYtGiRSHbYiRcKli0yD0yhGvA8qXRaAZ0mZcqXJWVlXA4HPK2PtI+iiqVatArCMdCoMDldrsV2/r47qNIgSuyUcAik1Kg7W6CDViiKKKqqgoHDx7E7NmzkZqaGtIPsHCpYE2mNg2RbKIELF86nQ6JiYlITEwEADgcDrkHV1lZGVwuF6xWK0wmE4DBWzWMJX+BS/qZI1W4OI5TBC7pKkUSOShgkUllqN5W0m/Dg+nr60NhYSE8Hg/y8vJgNptDPs5wqGABymlA361yxjsAjoZI/YCbqAHLl16vR3JyMpKTk+Uu8x0dHWhuboYgCPjyyy9hs9nkKUWLxRI2gct7P0fvwOVyueRAJgUu76sUycRFAYtMGsH0thqqgtXc3Izi4mIkJiZi9uzZo7YJbrhXsABagzWRRErA8ubdZd5gMMBut2PhwoVyhevQoUMQRVFeLB8VFQWLxRIW70MwgYvneahUKmg0GnlKMRzGToJHAYtMClLVaqjtbgIFLEEQUF5ejoaGBsydOxfJycmjOt5wqGBNtinCSA6MkRiwvImiCLVaDZPJBJPJhLS0NDDG0NPTo+gyz3Gcosu8yWQKi/cl2MDlu4YrHMZOAqOARSKab2+roTqy+wtYvb29KCgoAM/zyM/Ph9FoHNUxA+ExBUeL3CPHZAhYvlOBHMfBYrHAYrFgypQp8lXC7e3taG1tRXV1NVQqleIKxbHa1mco3oFL+ncmiiL6+vpQUFCABQsWQKvVQq1WgzGGlpYWTJ06dTyHTPyggEUilnf7BSC4xqG+Aau+vh4lJSWYMmUKZs6cOWbrOWiKkITSSDd7niiCWdzO87y8rU9GRgZEUURXVxfa29vR3NyMyspKxbY+0dHRw+6HNxq891AUBAG9vb3QaDRgjMHlcqGyshIrVqxAX1/fOI+U+KKARSKOb2+r4ewjKAUsj8eDkpISHDlyBAsXLkR8fPwoj1opXKYIB2s0SgFr4pgMFazhvj5pU+qoqChkZWVBEAQ5cEnb+uh0OkXg0ul0o/QKgiMIgjxdKL1eh8MxKhfakONHAYtElOPdpJnnedjtduzatQs6nQ7Lli0LyV5pwxXuFaxIDViRGkImQ8A63gtOvKcLgf4u89K2PocOHUJJSQmMRqOiy/xIt8IaKUEQBqy9stvtFLDCFAUsEjEC9bYKFmMMDocDra2tmDZtGqZNmzZuH0rhUsGaTFOEkfZ6vE2GgBXqKVC1Wo3Y2FjExsYC6O8y39HRgY6OjgHb+kihK5htfY6H9LPNW29vr9wHjIQXClhkwpN6W3k8nmFPCUrcbjeKi4tht9uRlpaG6dOnj9JogxMOFSzgh7U7TqcTGo1G7lQfqRWsSDUZAtZovz6NRoP4+Hh5uYDL5ZKvUKyurobdbpe7zEdHR8Nms4VsZweJVMHyRgErfFHAIhPa8U4JAkB7ezsKCwthsVgQHx8/LlOCvsKlgiWKIg4cOIDy8nIwxmC1WhETEwOHwzGuYyPDMxYBZDyNRwd3rVY7YFsfqQdXeXk5nE7ngMB1vNOYgQIWTRGGJwpYZMIKtrdVIIwx1NbWorq6GjNmzEBGRgb2798/7sEGCI8KliiK8gfGCSecAJ1Oh+7ubrS1teHo0aPylGx0dDRiYmLCpqcQGWgyVLBGq+lvsHQ6HZKSkpCUlAQAcpf59vZ2lJaWwuVyKbrMW63WYYdCfwGrp6eHAlaYooBFJhzv3lb+trsJhtPpRFFREex2O3Jzc2Gz2QD0BxupGjaepCm48fpg7O7uxqFDh8BxHE466SS52aHZbEZycjJqa2vR2dmJ6OhotLe3o6amRr7EPSYmBjExMeN+xdVIRGoImQwBK9zaUBgMBhgMBsW2PtIvLIcPH4YgCMPe1sdfwLLb7TRFGKYoYJEJRWqhcDxTgq2trSgqKkJ0dDTy8/MVC1OD3ex5tHlvEjvWH4xS76+oqCio1WpotVq4XK4B49NoNEhPT0d6ejpEUURnZyfa2tpQX1+P0tJSGI1GOWxJj0XGx2QIWONdwRqM97Y+qampYIyht7cX7e3t6OjoQF1dHRhjii7zZrN5wNeMKlgTC/3EIxOCd28r6cNiuB8YoiiiqqoKBw8exKxZs5CWljbgMVQqldz1fTxJ4xrL38xFUURpaSmampqwcOFC+QPAezze4/OewuR5XnGJu3TFVVtbGyorK+FwOOT1WyOdHhlt4z0lO5omQ8Aa7Sv4QkmqBpvNZkyZMkXe1keqcEnb+nhfoWgymWgN1gRDAYuEPd+F7CMJV319fSgsLITH48GJJ54Ii8Xi97xwrGCNBbvdjoKCAgBAfn6+vHmu9Pz+PqAHG5vvFVfS9EhbWxsOHz4MURTlD4+YmJiw2aIkUk2GgBVugX04vLf1kSrC3d3daG9vx5EjR1BVVSXvQ6jVamG322EwGMBxHOx2+5g3QibBoYBFwtrx9rYCgObmZhQXFyMxMRGzZ88edCohXAKW9DrHImAdOXIERUVFSEpKwuzZs+UPKu8qlb8K1nBI61FSUlLk39alxfLV1dXQaDSK9Vtj3cAx0k2GgBXOU4TDxfM8bDYbbDYbMjMz5W19Kisr0dfXh927d+Pbb79FS0sLKioqMGPGjPEeMvGDAhYJS6HobSWKIsrKytDQ0IC5c+ciOTl5yPuEW8AazbEwxlBVVYUDBw5g7ty5SElJ8XtOoPGNNPx5/7aekZEBQRDk9VtSx2yTyaRYvzVWH56RGkImQ8CK5NcnbetjMpkQFxeH9PR0JCUlYevWrXj33Xfx3HPPYfv27TjllFNw6qmnYvHixREVOCcqClgk7ISit1Vvby8KCwsB9E95GY3GoO4XbgFrtCpYLpcLhYWF6OvrCzhlOlad3FUqlRympLFJ67ekfkI2m02xfiuSP0xHw2QIWBN5ijBY0hoslUqF2bNnY/bs2di2bRuuvvpqLFu2DJ9++imeeuopPPzww+PeLJlQwCJhRhRFuFyuEVetAKChoQH79+/HlClTMHPmzGH94A2ngDVazUY7OjpQUFAAm82G/Pz8gFf3DbUX4WjxbeBot9vl9Vt1dXUAoFi/Ja1FIf5JX8NIDiCTLWB5k/YinD59OqZPn45f/vKX4zQ64osCFgkL0pSgdJXgSMKVx+NBaWkpWlpasGDBAvkDejjCJWABoW82yhhDXV2dvGYjIyNj0Pc4XDZ79r28XWp22tLSgsrKSuh0OjlsHc8GvJF6FWGgdXSRZDIHLLqKMHxRwCLjLhRTgt3d3SgoKIBWq8WyZctGvN1NOAWsUFawPB4PiouL0d7ejiVLlsjtFIZ6/sGMRyDhOA5WqxVWqxWZmZkQBEHuli1twGs2m+Upx1BsTzLRUcCKHNQHa2KhgEXGTSh6WzHGcOjQIZSXlyMzMxPTp08/rg+ScApYoapg9fT0YO/evdDpdMjPzw+6w7rvVYTeYwmXzZ5VKhViY2MRGxsLoH/9Vltbm7w9idvtlrtlx8TEwGKxDFm1izQUsCKHv6slqYIVvihgkXEhbXdTUVEBAJg2bdqwPwDcbjeKi4vR0dGBxYsXyx+yxyOcAlYoKliNjY0oLi5Geno6ZsyYMawPofFag3U8tFqtvB+ctD1JW1sb2tracPDgQXAcJ08lSuu3It1kCViToVIZaIqQtsoJTxSwyJiTqlbStjcjucS6o6MDhYWFMJvNWLZsWcj6JoVTwDqeCpYoiigvL0d9ff2I16ON1VWEo8V7e5K0tDS5eWNbWxuam5tRUVEBnU4nTycKghCRIWSyBKxIfn0S34DlcrngcrmoghWmKGCRMeM9JSiV9NVqNfr6+ob1GAcOHEBVVRWmT5+OzMzMkP5gDZfNnoGRV7AcDgcKCgogCMKwWlT4e/5wWOQeKt7NG7OysuDxeOT1W7W1tejt7YVGo5HbRthstoiYdposASsSvlaDkS4E8n6dvb29AEABK0xRwCJjItBCdpVKFXSgcTqd2LdvH3p7e5GbmwubzRbycU70CtbRo0dRWFgYVNf6YHh/OHu/L5HwYa1WqxEXF4e4uDgAQFlZGfr6+uB0OrF//354PB5ERUXJU4r+Nt+dCKSv20Qce7AmS8BijCn+TdvtdgAY8S9RZHRRwCKjbrDtboKtGLW2tqKoqAjR0dHIz88ftY1dwylgDadKxBhDTU0NampqMHv2bKSlpY3680+0CtZQVCoVTCYTZs6cCcYY7Ha7vH6rtrYWPM8r1m+N9ErVsRbpTUb9BY9IJP2c9H6dvb29MBqNER8uJyoKWGTUBNPbSqVSDRpoRFFEdXU1Dhw4gFmzZiEtLW1UPyxUKpX8A3u8P5SCnSJ0uVzYt28fenp6sHTpUlit1pA9v/dmz4FuiyTS15zjOJhMJphMJkyZMkXeC66trQ2NjY0oLy+HwWBQ9N8K1LB1vIXD9/JomgwVOsB/wKIWDeEtPH8ikAkv2N5Wg00ROhwOFBYWwu12B9zOJdSk3wTD4aqkYKYIOzs7UVBQAIvFEvLK3mRrZzAYaS+4qKgoAP19xdrb29He3o7q6mr09fXBYrHIYSuc1m9NloAVLu/3aPE3A0AtGsIbBSwSclLVKpjtbgIFrJaWFuzbty9ka4mCFU4Ba7AKFmMMhw8fRllZGaZNm4asrKyQf4hOtinC4VCr1YiPj0d8fDyA/l8GpO186uvrIYqiYv2WyWQat5BDASsyBGrRQOuvwhcFLBIyUm8rj8cDILiO7L5rsLzbC8yZMwcpKSmjOmZ/45HGMd4CVbAEQcD+/ftx9OjRkPX/8ifSriIcyvEEEb1ej+TkZCQnJ4Mxht7eXrS1taG1tRXV1dVQq9XydGJMTEzQzV5DgQJWZKBtciYeClgkJLzbLwA/bFY8FO81WL29vSgsLAQA5OXljUvzPGnM4RCw/FWwent7sXfvXmg0GuTn54/qQuuJ2Gg0HHAcB7PZDLPZjPT0dIiiiM7OTrm6VVpaCpPJJAeuqKioUV2/NRkCVqSHK4AC1kREAYscF3+9rYbzw1yaImxoaEBJSQlSU1ORnZ09bj8wOY4LmysJfStYTU1NKC4uRlpaGmbOnDnq75FvwPINW5FWwRotPM8jOjpa3v/R7XbL67cqKyvhcDhgtVrl6pbFYgnp15YCVmSggDXxUMAiIxaKTZqlxygtLcUJJ5wwoo7joRYuAUuqYImiiIqKChw+fBjz5s1DUlLSmI0hUJPKSJwiBMamMqfRaJCQkCB/r/f19cnrtw4fPgxRFOVAFhMTA6PReFzjooAVGWibnImHAhYZkcF6WwWru7tbnhLMz88Pm33hwiVg8TwPt9uNb7/9Fm63e8ynTWmKcGwYDAYYDAakpKSAMYaenh60tbXh6NGjqK6uhkajUazfGu62UFKLlEg12QMWVbDCFwUsMixSbytpD8GRVq0OHTqE8vJyTJkyBQcOHAjZXoKhEC4By+VyoaWlBYmJicjJyRnzPkuTbZF7OOA4DhaLBRaLBRkZGRAEQV6/dejQIZSUlMBsNivWbw11tStVsCKDv4BFfbDCGwUsErRQTAm63W7s378f7e3tWLx4MaKionDgwAG/PzzGy3gHLMYYamtr0dbWhtjYWMyfP39cPiCHes5IC1jh+HqkfRFjYmIA9Iduaf1WeXk5nE4nbDabYv2W79eNAlZk8Pcz0m63j+mSATI8FLBIUIbT2yqQjo4OFBYWwmQyIT8/HzqdTv5QC4eKkWQ8A5bb7ca+ffvQ1dWFhISE415/czy8q1T+1mCRsafVapGYmIjExEQwxhTrt+rq6gBAsX7LYDBQwIoQ/nrz0RRheKOARQbl3dsq0HY3wTzGgQMHUFVVhenTpyMzM1OxJUmw+xGOlfEaT1dXFwoKCmA0GpGfn4/q6upxrarQFGF44zgORqMRRqMRqampYIyhu7sbbW1taGlpQWVlJXQ6HQwGAzweD1wuV1hNxYfKZAlYHo9nQP80CljhjQIWCUgURXg8nuOaEnS5XCgqKkJvby9+9KMfyVuNeBtsu5zxMB4VrMOHD6O0tBRZWVmYNm2a3EcsnAKWv6mnSDORKz0cx8FqtcJqtSIzMxOCIKCjowOHDh2C0+nEV199BbPZLE8n2my2sJmWPx6TJWD5e50UsMIbBSwygHdvK2l6YSQfPK2trSgqKkJ0dPSg++SFW8AaagPqUBIEAaWlpWhubsaiRYsQFxcn38Zx3Li+L9LX3F+QmshBZLJQqVSIjY2Fy+WCKIqYN28e2tra0N7ejtLSUrjdbnn9VnR0tN/1WxPBZAlYgiAMuNCF2jSENwpYRMF3u5uRhCtRFFFdXY0DBw4gOzsbU6ZMGfQxxntRua+xGo/dbkdBQQE4jvPbpiKYzZ7Hgr81PONdXSPBk75+Wq0WSUlJSEpKAmMMdrtdXr914MABRUNUaf3WRDCZAhZVsCYWClhEForeVg6HA4WFhXC5XDjxxBNhsViGvE+4VbDGImC1tLSgqKgIKSkpmDVrlt8PiME2ex4Lg1WwBjs+UUXa65EECsgmkwkmkwlpaWkQRVFev9XU1ISKigro9Xo5bEVHRwesQI+3yRSwqE3DxEIBi4SktxXQHxr27duHhISEYfVtmkwBizGGyspKHDx4EPPmzUNycvKg4xjvNVjAD8FjsPVYJHwFcxUhz/Ow2Wyw2WzIysqCx+NBR0cH2traUFtbi+LiYlgsFsX6rXAJNZM5YNntdgpYYYwC1iQXit5WoiiivLwchw8fxty5c5GSkjKs+4fjVYSjEbCcTicKCwvhdDqRl5c35A/GcKlgBbotUis+kWYkbRrUajXi4uLkNYFOp1Nev7V//354PB5ERUXJ1S2z2TxuoXuyBiyp6z+twQpfFLAmMVEU5QWwI61aSeuIgP7tbkbyj30sF5UHYzQCVnt7OwoKChAdHY3FixcHVd0LtwqWr0gMWJFYmQtFHyydTofk5GQkJyeDMYbe3l55/VZtbS14npfDVkxMDPR6fYhGPzR//aEikW/Acrlc8Hg8VMEKYxSwJiFpSlC6SnCk4aqxsRH79+9HamoqsrOzR/xbZCRPETLGcPDgQVRWVmLmzJlIT08P+r0OlwrWYFcRRlITy0gMjEDov0Ycx8FsNsNsNmPKlCkQRRFdXV1oa2tDQ0MDysvLYTAYFOu3RnObJ1EUw3Z9WCj5Bqyenh4AoIAVxihgTTKhmBL0bi1wwgknICEh4bjGFI5ThKEYj8fjQXFxMdrb27FkyRJER0cPexzhWsGKlFA1GYz2Zs88zyMqKgpRUVGYOnUqPB6PvJ1PdXU1+vr6FOu3rFZrSMczGaYIpdY53gHLbreD47gJc7XnZEQBaxLxrlqNtLdVd3c3CgsLodFo/LYWGIlwrGC53e7jeozu7m4UFBRAr9dj2bJlI+qgHU4VrEBb5URSBStSjfXXSK1WIz4+HvHx8QD6ryyW1m/t27cPoigq1m+ZTKbjGt9kCFjSz0fvgCX1wKJ/f+GLAtYkIPW2Ki0thc1mQ2Ji4oi2uzl8+DDKysqQmZmJadOmheyHWqStwWpoaMD+/fuRmZmJ6dOnj/gH4HhXsCSDfUCHw/jI4MY7BOv1eqSkpCAlJUVev9XW1obW1lZUV1dDrVYr1m/5bgczlMkasKhFQ/ijgBXhpN5Woiiit7cXOp0u6B+2jHnA2HdwCzvQ2/sNzNZ25C9Lh4bnIbisYFwmOC4T4BeBV6eOeIwqlQpOp3PE9w+1kQYsURRRVlaGxsZGLFiw4LinTsf7Sr3JOEUYia9rvAOWN+/1W+np6RBFEZ2dnWhra0N9fT1KS0thMpnksBUVFTXk+q3JErCkfVsl1KIh/FHAinCCIMiNQ9VqdVBTcSJqIOBtMByA4KmDo88NxmwwmdQA9w0YAAYDGBrAiXsA5x8hOjjw3Exw6rPAac8EhvEDPRzXYA03YPX19aGgoACMMeTl5cFoNI7LOEItUMgb6gpDEj7CKWD58u4eDwBut1tev1VZWQmHwwGr1Sqv37JYLAPC1GQJWL5XSvb29obk5wwZPRSwIpz0Ww/HcVCpVPIWOP6IKIQHL0LEFwDTwOmYCVG0Q2v0QK1KAse0EFk7OPQC6ANDMRgPQAcA6WDuGjD3A+CcD4PnUsCplgHan4NXD94XKxynCIcT+I4cOYKioiIkJSVh1qxZIbtkfLwrWN5jmAxThJH0WryJohi2AcuXRqNBQkKCXP3t6+uT20EcPnwYoigqrk40Go2TNmDRFGH4o4AV4byvEgxUwRJRBQ/+DhFfAawZEHPgEaqh05fK5zDsBeMAQA2wmeCYGSJrA48oAB4w1EDU2AENwBgP5qkDJ1QCjk0QmQ08vxCcei047eoB1a1wXOQeTOBjjKGqqgoHDhzAnDlzkJo68mlSf8Z7kbs0huEcJ+FntK8iHE0GgwEGg0Fev9XT04O2tjYcOXIEVVVV0Gg0EAQBnZ2diIqKGtHFJBNBoArWRA5Y0rSnJNCFNBMZBaxJRKVSweVyKY4x9ELAe2D4Bhzi4BHV6OnugEYdC7XaCXC+a6M8YFwHwJkANEFEN3iWDo5NhciqwaEP4EQwjRNMak3j7gITPgdce8A57gfHTQGnXgZoLwavTg67gBVMRc3lcqGwsBB9fX1B77k4XOGwyJ2mCCe+cJ4iHA6O42CxWGCxWJCRkSEHq+LiYhw9ehSHDh2C2WxWrN+KlAak/pqpSlcRTlSR8rUZDAWsSUStVg+YIuRgggZ3gLHbceDgDvQ6PsKUjDroDEUAGDjMApgRDI3H/p4MhiIwNB17BDtE7gjAAf3lq2xwzATRWQ6Vpw9Mw4FpBIgaDkAPwHhwnpr+6lbfJoiIQpR+NjqN8wCWO6y1W6NlqApWR0cHCgoKYLPZkJeXN2pNDsOlgjVYiKKAFf4iJWD5UqlUiImJgUqlwuzZs2E0GuXpxPLycjidTthsNsX6rYn6Png8Hr8BazR+sRsLjDFcdNFFiIqKgtVqlYOzxWJBbGwsrFarvBm5xWKByWSCwWCAXq+fUFVKClgRzvsHSqBKkcPhQGFhIVwuhgUL7oTVYAWDEyK+gYgvIXDfgEMSGJoBcODYTDBUA3D5PJIb4HgwrgcwdEN08+DcGnAOD0QtA8fzx6pb6K9uMYBzd0HN7ULmlAK4uzaD5zPBqU4Cp70YnDpxNN+agAIFG8YYDh06hPLyckyfPh2ZmZmj+gN7IlSwIk0kvq5IDVgSaQ2WVqtFYmIiEhMTwRhTrN+qq6sDAMX6LYPBMGHel0irYPX19eGf//zniO5rNBrlLvbhjgLWJOJvkbu0QDshIQE5OTnyJdEcdFDhZKhwMjQARNRCxJf9f7hCADw4zAGYrv9qQsQBsINhv/zYTNM/VQgAEAHOKYIde3qeN0DUOMG0/UGGRx9EpgJzV4ATK4C+V8AjBhx/Ajj1j8FpTxuz6pa/KUKPx4P9+/ejra0NOTk5iImJGfVxhHMFi6YIJ45ID1j+1phxHAej0Qij0YjU1FQwxtDd3Y22tjY0NzejoqICOp1OEbjCuTISaA2WzWYbpxEdH51Oh+3bt8PlcsFut8PpdKKlpQXPPfccurq6sHDhQiQkJECj0aC6uholJSXo6OjArFmzkJaWNt7DDxoFrEnEe5G7KIqoqKjAoUOHMHfuXKSkDH6lH48s8MgCsA4MdojYDRFfQOTKwMEGhjZwSAbHdGCoAuDnakURgL6/eiW6+sAJZsDdA1GLY9UtAUwLMAAQeTBPByB+Cd69B8zxW/B8BjjVyeB0F4NTjV51y3eKsKenBwUFBXL3+uE2QjyecYRDgAk0hnC4yjGUIum1eIv0gBXMVYQcx8FqtcJqtSIzMxOCIKCjowNtbW04ePAg9u/fD4vFIgcum80WVmuEpFY73np7e0N+Yc1YUalUWLZsmeLYxo0b0dfXhz//+c84++yzFbc1Njbi5ptvRk1NDf7+97+P5VCPCwWsCOdvitBut6OwsBCMMeTn5w+7zMzBCBVOgQqnAABEVHpVtyoAaMAhG2BaMHYIvL0Vop6DaPohtPQHqWNl3mPVLXjQn640RjBNH5i2f+wCugG5ulUJ2Dceq27NB6c5F5zmlJBWt7wDVlNTE/bt24f09HTMmDFjTK/GCqcKFmMMTqcTWq1W8T0VqaEkkkRywJL26Bvuv0uVSoXY2FjExsYC6L9oRdrOp7S0FG63W7F+y2w2j+t7KAjCgIarE/0qQlEUIYoi1Go1KioqcM899+Cqq67C2WefDbfbLV8BL4oikpOT8fzzz2P58uV4+OGH8dhjj4338INCAWsSUavVcDqd2LlzJ1JSUjBr1qyQBAYeM8BjBoCrwdADETuPha0GgOPADGbwzj4wXgOmdQwMQx4AIiCaAPAA57KDc5sAsdenusX1V7cENZinHWBfgXd+C9bn7q9u8cvB6X8BThV/fK/nWB+s0tJS1NfX44QTTkBi4tivBwuHChbHcXC73SgqKkJrayt0Oh1iYmLkDyYS/iZym4ahSL+AHO/r02q1SEpKQlJSEhhjsNvt8vqtAwcOKBqixsTEjPkGy5HYpsG7hVB7ezuOHj2KBQsWAIDct1H6f6D/8ys7Oxs7duwYnwGPAAWsSYDjOHg8HtTU1EAQBCxatGjUAgMHM1RYBRVWAQBElEJkWyG6XgGLcgKiCrxDB4gOiDwDL/AQjRxE7Q9Bor+61YtjDwDOIYIJAM8AUacF1G4wVf+NAjzHphOl6tYr4BEHjp8DTnM+OM2KYVe3pK2F2trakJ+fP27dksNhQ2XGGEpKSmA2m7FkyRK4XC60t7ejtrYWjDEUFxcjPj4eMTExsFqtEVspmcgivYIFHH/A8sZxnHwFW1paGkRRlNdvNTU1oaKiAnq9Xl67FR0dPWpXEksEQRiwRmwiL3L3Je04smfPHlx00UWKap30vdvZ2YmqqiokJyeP1zCHjQLWJNDd3Y2CggL5h9Dx7pE3HDxmg1fPBt8ggv/2bbgzkiCYasF0aiDGA+bRgHcAIucGdGxAGOKOXajIzIDAAZzLDc6hBuD+obrFi/3VLQZA0IGJrQDbBd75NeBg4LgMcPyKY9WtuEHH29raioKCAgDA0qVLh9wHbTRJXy9/VxCNhebmZjgcDiQnJ2PWrFlwOp0wm82Ii+t/Dz///HPEx8ejt7cXhw4dAgB5SiU2NnbM1qqFUiQGkUgOWKGqYA2G53nYbDbYbDZkZWXB4/HI67dqa2tRXFwMi8Uif+/bbLaQjycSK1jAD//eMjIysHTpUvzpT3/CokWLkJ+fj6ioKGg0Grmi+Je//AVlZWX4+c9/Ps6jDh4FrAjHGMPevXuRmJiIjIwMfPbZZ37n80ebmPUL8HXvQtOog9ZuAgODaBPgiffAE+8GixLACSrwzmPVLY6BBw/RcGzRu/R6tAxM6z72oP3Vrf719DyYgQPUjmPnuyAAgMiDC1jdWi4HOsYYampqUFNTgxkzZqCsrGzcP5TG60o97w71er0eKSkpfj8weJ5HfHw8srKywBhDV1cXWltb0dDQgLKyMphMJsTGxspNHyN1mircRXLAki7aGcvXp1arERcXJ/+i4XQ65fVb+/fvh8fjQVRUlFzhCsX6rUgNWJLU1FSsX78el1xyCX7xi19g8eLFyMnJgc1mw+HDh/HFF1+gsbERZ511Fm666abxHm7QKGBFOI7jsGzZMsXCbY/HM/aVGUMyWOJK8E2fQLRmg+8qh6pTDVWnGroqPdwaHiwR8MR2AVo1EOcGc2nBO9RgXC+YFsrqFgN4B8BUADMCgAjOpQbXJwIcg6gDOM6ruiVy/dUtdhRgu8E7vgL6eHB8Bhi3HPsqTkBXN4/c3FyYTCaUlZWNW+VIIv1QHsuF7h6PB0VFReju7saJJ56IoqIieZG7y+VSTIV4X0XIcZz8W/7UqVPhdrvR1taGtrY2lJSUwOPxyOtXYmNjw7IH0XivdxstkRywpPVl4/n6dDodkpOTkZycDMYYent75fVbtbW14HleDlsxMTHQ6/XDfo7JsBfhmjVr8K9//QtPPPEEioqK8Oabb8LtdkOtVsNoNOLmm2/G//t//29Crf+kgDUJqNVq+Uqb4W5kHEpi+nngmz7BsbbvChq3CHfXCTAeLuqvbkVp4Yl3w5PQC2YVAUEN3qkBE51gYODUaohGZfBgWk9/EAMAAYBTBOcBwOnADG5A03esutU3oLo1dwYHHvHg+TlgwvkAGARBGPW1FYORKj5j9cHf29uL77//Hnq9Hnl5efIVg4IgoKSkBE1NTdDr9XJVSgpe/mg0GkXTx97eXrS1teHo0aOoqqqCTqeTHyc6Onpcp2Ij3UTa7Hm4wm2jZ47jYDabYTabMWXKFIiiiK6uLrS1taGhoQHl5eUwGAyK/lvBfO/7C1h2uz1i1mAdOHAAtbW1OPnkk/Huu++iuLgYBw8ehMPhQFxcHHJyciZkmKSfapPMeO77x2IWg5nSwXWVg+liwTlblWPrrQHjteBEF1Qdaqg61NBVGuCJyQQzlMMd6waMarBoF+BUg3dowbjugdUt8Vh1SwuIRgBwgnNpwblcAI/+tVte1S3RowLPtBDZEYj4FrzzC5xyIg/emQVRPO1Y363RbyzqaywrWC0tLSgqKsKUKVMU7SikfmlarRaLFy+G2+1Ge3s7qqur4fF4UFZWhoSEBMTGxgacCvH+0ElPT4cgCPJv+NXV1ejr65MviR/sccZCJAaRSK5ghVvA8sXzPKKiohAVFYWpU6fC4/EM+N73Xr9ltVr9vh7fgCVtfD0RQ4c36XW9+eabeOutt/Diiy9i6dKlmDdvHubNmzfewztuFLAmAd9eWL7d3MdwIBCnnAtV2bMQjVMGBCxe6IEYNR9cxz7FcXXbATDTDGjq68A4BiFKCyHhWHXLIgIeDXinGkx09C9012khmpSvkWldyuqWQwQnAIzXgzO4wNB37MZeCFqACSKYUAlBrALsfwGP+GNrty4Ep1k2Jl3lOY4b9Wae3mvP5s2bp7hCp729Hb29vYiOjsbChQvhdDphtVoRH9/fBuOrr75CTEwMurq6cPDgQXlvOOlPoM7YKpVKsYalr68PbW1taG1txcGDB+UpFanCFc4dtieCSA5Y/hpwhjO1Wo34+Hj535DD4ZDXb+3btw+iKCrWb5lMJrmK7B2wHA4HRFGc8AFL+tl26NAhdHd3y6/He+/Fify9SwFrkvHu5j4exNQzwZc/D673IBh4cPCpznj87zHFNFZwADjGQd2uhrpdDV054EmcBVFTCCHGA9GqBrN4wDl5cH16ML4PTOfzj1Por26Jehxr9eAA59KBczkV1S1OxcBUHJhHC46pIbBmAHbwjs/AHFrwXCY49angtD8f1erWaDYb9Xg82LdvHzo7O7F06VJYrVb5trq6OpSXl0Ov1yM1NdXvhxjHcYiLi0NUVBREUURnZ6e871tJSYm8cetgv5kDgMFgQGpqKlJTUxWPc+jQIflxRvMKrUgXyQFrovf4ki4iSUlJkatS7e3taG1tRXV1NdRqNWJiYuB2uxU/t+12OwBM+IAlfe0WLVqE//u//0NTUxPmzp0bMUsGIuNVkKCN5xQhAEAbBRa3FPyRnRCt2eC6yhU38z21YMZUcPZ6xXGuo7Q/ZLm7FMdV7c1QuY3QHhb6q1sxnv4rExMZmEEE3Brw7v7qFidyEPQqRUd5AGBap6K6xdlFQASYxgDonGDyptbdELQARDeYpxycUHGsuhUHjp8LTnNByKtbo9Vs1G634/vvv4dWq0V+fr5cJRJFESUlJWhpaUFOTg4qKyvlD2ffiyO8q2vejRinTZsmX1nV1taGffv2gTGG6OhoOXAFWujr+zhSh+3W1lYUFxdDFEXF44Sy4SMtcp94wn2KcDg4joPFYoHFYpGn0qX1W4wxFBQUwGQyYefOnZg2bRo4jpuQrVC8SV+7Sy65BFu3bsX//u//IjMzExkZGRERsib+KyBD8v7hqlarx2+K8BgxZRX4IzsB3v/UD9PFDQxYECCap4JrL1Aed7XL04oc46Bu1UDdqgHKACEmE4L5IIRoDwSbCoLZA86pA+8WwHjPwOqWB+CdP3SUB+sD5/a3douBaTgwQQeOqSCwFnCsD5zjU6/q1ungtBcdd3VrNCpY0gbfKSkpyM7Oln/IOZ1O7N27F6IoIi8vT77STxRFlJeX49ChQ4pF7oPxvbKqu7sbra2taGxsRHl5OYxGozwNONi+b74dtnt6etDa2ipv2GswGOTqVnR0dFjtHxcuKGBNTCqVCtHR0bBarTh48CCWLl2K7u5ufPDBB3j77bcBAFdffTXOOOMMnHbaaWPa3zBUpK/f22+/jY6ODrzzzjsoKirCOeecg6lTpyI6OlretNtkMkGj0SAjI2PCBEsKWJPMuFewALCE5WAqA7iuKjBeA050K27numvAOBU4phwn19fk/wE9vX4Pc2IctHVNQJ0OjJeqW254klRgBld/eHLzYKITnMhBNPIQTV5VDG7g2i2uT6puGQGtQ+7RxXCssqaobr0EHrHH9ky8EJwmb9jVrVBWsBhjOHDgAKqqqjBnzhzFRrGdnZ34/vvvERMTg3nz5slBhTGG2tpaAMDChQvlBepVVVVwOByorKxEYmIiYmNj5fUivrw32s3KypIXyre2tsr7vgXTwsH7N/zMzEzFguGKigo4nU5ERUXJATDQeCabSA5YE20N1khIv2Dp9XqYTCY8/PDDOOecc3DZZZfh8ssvx8cff4w//vGPOOmkk/DEE0+M82iHR/rZ9te//hU7duxASkoKSkpK8N133wW8z86dO3HiiSeO1RCPCwWsSSYcKlhQGyAmLoeq4SOItrngOvcrbuY83RCts8B1lSmPO5rALNPBdVcpjvM9NWCGFHB9DcrzO/bDCTN06AEnclAf1UB9VANWaYWo64EQ1wfB5oEQq4JoFMC59OA8fRDVDND6fCC5AN597KpEHgCz9/fdcnsCVLf04BgPgR0Bx74F5/zkWHUr61h168KgqluhWuQuCAL27duHjo4O5ObmwmazybfV19ejpKQE06dPR2Zmpvxh3N3djc7OTphMJuTk5MDtdkOj0cgLdHfu3AmbzYbOzk4cOHBA3kBXqigFanGh0WiQkJCAhISE42rh4L1gmDGGvr4+tLa2oq2tDTU1NVCr1UGNx1skBpFIDlgTfQ1WMKSf196v0263w2w2Y+XKlVi5ciUeeeSRcd8YfiSkX+Qef/xxNDQ0wOVywel0wul0wuFwoK+vD319fXA4HHA6nWhsbFT8YhjuKGBNAr5XEY53BQsAPKY1cHc3QWWMBoxZ4O21yhN4/x+GTGX000ULYPqEgQELDKJxCmAvVR73dIGzLID2YCGAY9WtWA888S54ktSA3gnm1ID38GDMBU7kwYz9IcrrwcF0HjCpUu05tnaLAUyjG6S6VQZOKAf6XgTPjlW3tBf1V7f88G4QO1J2ux179+6FWq1GXl6eXF6Xpv4aGhqwaNEi+ao+AGhqasK+ffug1+uRlpYGtVoNt1tZaZSuBoyNjYUoivL2IQcOHFAsco+NjYXFYhnVFg4cx8lTCVL/Ie/x7N+/H1arVX6cybRvYiSHkEieIpRIDY+9v1/97UM4kd+HiVKRGi4KWJPMuLZp8MJlLIK49Wl4mtrg4TkImgyIiTaYYgDeUXVs+rC/J5bifoGmD7urwDg1OKZ8bXrPETBw4KCsAnGOlh/+X+SgPqKB+ogG4uFsMKEEQrwbglWAEM+DaURwLjM4jx2ihgGaANUtM/p7qDJn/5WMHtFvdQsePQCpuvUNuL5PwPq8qlu6i8Dx0f1jO841WNLeitJ+gtIPYZfLhYKCArhcLuTl5ckbWntvk3PCCSfg8OHD8jj87QDgvchdqhRNnz4dTqdTriYdOnQIHMcpWjgEWkMxVAuHYFtBDDYe6TVN9H0TgxXJFazJELAmQxd3URTHvbHzaKCANcmo1Wr09fUNfeIo4zQ6cBmLwKp3A/EzoGquhOpAC1wHAHA28FOSoIq3gPfUgHcc/uF+Qo//6UNPDzzmmVD3VCiPu476vVqR62sEM08D11OtOM53lYMZM6A60P+cTNVf3XInuCAkcIBO6G/r4AZE5gLHdGBG98Dqll78IdJJ1S0RYFoNmNYhn8rQ3f8/3tUt+0vgWQw4/gTYzHPAWPZw314wxnDw4EFUVlZi9uzZSEtLk2/r6urC3r17YbVasXjxYjk0eTweFBYWore3FyeeeCIsFgvq6+shiiKqqqpQW1s7YJF7oOlLnU4nX34uiqK8yP3w4cMoLS2F2WyWH2ew1guBWjj4toKQqmSBHsd7PNK+id7dtY1GI0RRhEaj8fuBNpFRwJrY/K0zk6YII4W0y0h9fT2am5shCAL0ej3MZjMMBgN0Oh30ej30ev2E+l6mgDXJhMsUIQBw00/sD1i8z4cZYxDrGiG6rUCjB1xUNlQpUeD1PeD7qgDe/7dtV08f/K5q4vyfz9QBpht1MeDsxyo3Agd1iwbqFg3EmIVgrj391S2LAJbAg6ld4F0mwGMPvHbL413dcoNz9h9jAatbHAQcASd+jTnTt4GxP0PonnasuvUzcLzNd8gKgiBg//79aG1txY9+9CNERUXJtzU2NqK4uBhTp07F1KlT5R9W3tvknHjiiXJliDGG+vp6CIKAE044QZ56q66uht1uR01NDex2+6CL3HmeV+xTKLVeaGtrk1sveFelArVeGKwVhLRnYjCtILz3TfRedF9ZWYmWlhY0NTXJi+5jYmJgNBon1A91XxSwJjZBEAZUjv1NEU50r776Kv72t79h7969cLvdcLlcYIxBo9HAZDJBp9OB4zjU1dVNmBYOE2OU5LiETSd3H1xWDsDxQOshMI4Hx3ymwo7WARwP1tEJT0dn/zF1HPg0HVQxP4LKUwfO2SyfHsUdAeP8TCt2VYKp9OAEh8/xiv41XYJdebyzAgKnhYr5Pk4VONEIVa0TAMDUDJ5YNzxJHIRYBuhFZXULJjBDn5/qVn8zeQBe1S0eTMv7VLeONV0VPWCeUnBCGWB/Ua5ucdqfgdMsVYyxr68Pe/fuBc/zyMvLk0MGYwwVFRU4dOgQFixYoLik+8iRIygsLERaWhpmzpwpf2BJm9ZqtVosXbpU3nhVuu/u3bthtVoHLHKPjY1FdHR0wHJ/oNYLTU1NcusFKSRFRUUFrCaFqhWEtOi+qalJ7qItLbqvrq6GVquVH2ci7ptIAWti81fB6unpgcViGacRhd57772HK664AnPmzMHatWvx9ttvY86cOTAYDDh8+DBaWlqQlpYGnU43of79TZyRkpAY707u3ji9BVzqHLDDxXBbU6DtUi5Sh7sPiM8CjngtgPcIEA/UQ+ybDncz4DRPgxCjgy3GDZWjBswya+BVicwF0TIPXEex8rjohBh9Arj2Ip/jDti102BxKacPOU8PxKgTwHUUHfs7B02zFppmQLTlgYmF8CR4IJo9YPE8mMoOzmUEJ/QFXrslV7dEgIngHf1Vsx+qW9wPVyZ69ODAQWBHwbFd4BzbvNZurUKHfRUKCquRkJCAOXPmyD+U3W43CgsLYbfbceKJJ8pTC1ILhurqasydOxcpKSny0I4ePYrCwkJ5ak2j0fhd5B4TE4PExETFovLa2toBi8oHW+Tu23pBqkqVlZUNq4VDKFpB8Dw/YNF9R0eH3Fm7r68PVqtVDoCBXlc4oYA1sfmbso6kCpbD4cDDDz+MrKwsbNu2DUlJSXjrrbdw880345e//CUqKipw4403gjGG//73v+M93GGhgDXJhNMUIdBfxWKHi8E0/qdzoPU/XeQWGTTgoOvpBXp64a4D3NpU8NMToDbqwHsOgHO1/XAHFuA1e/yvR1OJAdapBdjKB0IfVD1qqLr7/0kxtdjfUT5FDyHKDuhEcE49OI8IkbnBcRYwfe+A6pZoAHBs9RbnAbheBohqMB3zuTLxWO8vr7VbJs3zWLY4GhrNInDCzwB+KXp6evD999/DZDIhLy9PrioJgoDi4mK0t7cr2jZ4r92aM2cOWlt/2C/Se38wYGAnd+9F5dIea62trairqwt6f0GpQia1cLDb7WhtbR12C4dQtYLwrsoBPyy6b2trU+ybKL22cNs3kTEW8QFrIlU0RiJQwJK+Jye67u5uFBUV4dZbb0VSUhIOHToEoL/xMQDMnDkTr7/+OubPn4/HHnsM995773gOd1gi+zuTAAi/Tu7euMzFwPbNUPV1+D+hvcHvYdZaP/DqQJcLYkUNXKIHEDXgkk6AKsEAleoouK5q/9OB3VVgGhs4d6fiuNHTAJc6FlqPz4bUAXpu8T01YKZ0cL11/Y/r4aFp1ELT4IFoyAbTHoYn3g3RIoLF8WCq3v7pRMEBUQO/1S1OujKR9wCsfw9FzsOBqQEmrfU6Vt0SXBrwahU4tENgO49VtzTw9MRjVtZKxKVcD17VH658pxGlK+j8rd1qa2uDKIqora1FVVUVtFqtHDgG68/lvceaKIro6upCa2urYn/BoRancxwHk8kEk8k0oIWD1OjUZrPJjzNYo9NArSC8H8flcsFoNA4aSHwX3Uuva7iL98eK9DWK5IA13u/xaAsUsDIyMsZpRKHV09MDxhjS09MBQK6Ue/98MRqNyM/Px7/+9S8KWCT8SNWGcKtgIWYKYImDuvsoXBoztG6fCpG9A4hKBjoaFYe1ogOInQK0HlKe73ECCVOBlhqwphZ4mgAPABhToZo+FSr9UfDOGnCe/qv3ODCI5kxw7YUDhuZSxQ0IWID/nlsAwLTRcsCScQD0CVC1N0HV2f/PTdSIEOI9cKeZIdgcgEY81uRUhAg3OFjBdD2DV7fcDJwDEAU1OK0IXucG4AYDwNAfIpnggVFdD5Pwdwh9b4OxGLg8s1FaMQ8220mYPXu2/OHkcDiwd+9eAFCs3QKA5uZmuN1unHDCCQCAjo4O1NbWore3F7W1tXA4HIP2qOJ5HlFRUYiKipL3F5RaJkiL04NpmeDbwsFut8vVpOE0OvXXCqK1tRW1tbU4dOgQmpqagm4F4fu6pPHs378fgiAMmJYcaxSwJr5AAStSriJ0u92IjY2VK1ZutxtGo1GuZElcLhd6egLMIIQpCliTTNhVsDgOXMZisOL/wqGzDQxYAGCKGRCwAAD6AIs81X6mG+19EFpcEJqaAZjAp06DKk4LnmsG3P632lEL7f7H3HvQf2+t7mq/vbi4zlJF9Yx38+AbtFA3q8CQBGbphifeDcEqgotWgal7wDt1gBigunVsz0TBBID3gAWobnEqBqbiwNw6cODhYUcBcRdOmPMFwP4K1psFUb0KXY7V2FtQhdjYWMydO1f+Ye5wONDS0gKe57F06VL5aqa4uDhMnz4de/bsgcFgQHd3t6JHlRRyBlvk7m9xekNDA8rKymA2mxWL0wN9gEqNRdPS0hRrwA4ePBh0o1OgvyqVlpaG1tZWxMTEwGw2K1pB+K4lCzQef4v329ra0NLSgsrKSkWLi7HaN5EC1sQX6QFLr9cjISEBO3bswO233w6TyYQ5c+bg/fffxy233ILY2Fh888032LZtGy688MLxHu6wUMCaZKQKVjity+Ay+wMWJ7j93u7qboffGkKv/wCEDv/Timg91N8SQhQg1jdBlPaTNmugzlgGXtfV3+RU6F9/pfe0gBmSwfUpwx3nagezTAO6/SyC97f1D3NBtM0euJhe6AOLXghVewFUHceqW1oRQrz7WHWrD1AzwKkD7xEhch5wzAKm64Xg/bM1QHWrv0u9u78z/bFTea2r/wpG0QXOUwrOUwaD6k/IXxQNtWYxePEiQLUU7e3t2Lt3L7RaLeLj46HT6WC3K6dXpQqONA0o9agaTsDxtzhdWrvlXQWSgslgLRykihOAETc65ThuyFYQ3o8zWCsIafF+RkZGwH0TpeA2WvsmUsCa+ARBGPD9arfbI2aRe3x8PH7+85+jurr/52lycjKuu+46XHvttZg3bx6mTZuGvXv3Ij09HZdeeuk4j3Z4KGBNEt5ThID/3irjhUs/AYxTweho7e9xJSorQOquRjC1DpzHqbxjRyNgtAF25fop2DuA6FSgvV553O2Qpw8VenrgaU8DGo4AfDRUabPhMrqg5pqg1ScNCFgAwNRmvz20Ai+m91/a9t3Amnfx4Ot1ULfGgDncEKM9EBLcECwMnE0NUdULzqEGzx1rbqr2GYUAcM5jeyaqnADjwDtYf3VLBTCd19otLQfBpQYPNTi0Q2Q7wBwfg9m1QF88Fsw+DS1ty/urjBwHt9s96CJ332DiL+AMtchdo9EgMTERiYmJihYOzc3Nw27h4K/RaX19/aBrpXyDyHBaQURFRQX8sPfeNxH4YXqztbVVnt4Mpvo3XBSwJr5I7+RuMBhwww03oLOzE06nEzqdDr/4xS/Q2tqKjRs3oqGhAbm5ubj77rtx1llnhVVxYCjh8QlLxowUqsIqYGkNEBOmQdVcAcT5tGUAwIMBselAc+XAO0clDwxYAGCMGhiwAEAdYEsUaV2aKEKoa4AKAIMazmQV1DFLodJ1g+urkntscb11/qcJu6r8Lqbnu6vB9EngHM3K8x1NYOYscD21PsebwWyzoG4vg7r9WHVL11/dcqXqIdraATUD5zKAc3kgqjyAYAB0zv6F8fIDsYHVLScgChrwKg94gweAR7F2C4IbJs1hcMKrsJjfgOixoefIbFRUzUWvY7YcBKQr1PwJFHD8LXIPtC+gvxYOUuuF4bRwCLbRqcPhGNCKwnc8oWgFAQw+vemvxcVIQwQFrIkv0qcIASiqz4wxGAwG3HXXXbjrrrsGnDuRvpfD4xOWjBme58FxXHgtdAfAUucCzRWA1uj/BFWAb9VA+/Q5AiyG7Gz2f7y1zm/1DI2H4emMgsfeAagToEpPgsrGwAt1gGUa0F2lOJ2DB6JlNriOffC5AcyYPCBgAQDTWAJUw5R/5Z08+MM6qDqngeuphHCsuuWxieAMWjCDG7xLC7ic/qtbYn91i+kBqN0QGQfeIcp9t+TqlrR2S1CBedTgtO3QcN9hyfwdANPC6UpBS+sCdHcugt1uh8vlGjQo+Qs4/ha5S9WbQNN33lWgwVo4SNWkQL9ABGp02t7ejpqaGjQ1NQVVJQtVKwh/05tSdau+vj7oDvX+UMCa+CI1YEmVqH379uHjjz/GKaecgkWLFsmVce/quCAIEAQh7NqgDIUC1iQUbgvdAQBp84Hv34WjvQV+Pz66WvwdBdrq+7vB+3aBb60DNPr+aUFvvW2ANWHg43ldfThAVHL/tKPHA6Hm8LEu7Dy4aRlQGeOg0rSBs1f/sAF1gGlC7w2mFce7qsF4DTjR7XO8Am7OBA1TLsLnu6sgGNKgbquHuk0DHQBRL8IT74YnRQMhygGmYuAcevCCAKYSAFEHqFxBVbfAdABcYAYBnO7Yq9U5j63dckOjrkWa/gBSU96H4I6CvW8aaquWoKN3hhyUBusJ5bvIXdoXcKjpO8V7M0gLh8rKSjgcDkRFRcmPM1gLB6lK1tHRIa/z8q6SeT9OoG1zgm0FIT1OoCsugeCnJYcKgMAPH2IUsCauSG00Ks2ivP/++7jvvvuwYMECPPXUUzjllFPk71kpZFVXV+PSSy/FmWeeiQcffHCcRx48CliThO92OeFWwXLFZAC8Bjr7ETCNAZzbp9FnT2v/1YS9bT537PXfrgGsvwWEv2lFS5z/wBZw+tDftBEH1twMT8/R/jYQujSopiRAZRXA9x32vzWPvf5YDy2fRfNCL0TbHHCdJT7PIKKLxSEWA69y7HSoFfsu8g4e2kM6OBozYRFqIcR44ElwwxMlgtPoIOrdgEMF3uOBqAOg8hMS3ADTAEznBEQOvFP033dLx4GJHES3GjzfDouuBAut3wJMB6crBc1HT8Cu8kUwmhLlQGG1WgMGJd99AaXqlvf03VDVm0AtHFpbW1FTUwONRqN4nMEai/qrkkmd3KU+YME0KPXXCsK7pUQwa64Gm5YMJgBOpPUqIzEZApYoioqAJYpiRFSwJO3t7VCr1SgpKcFll12Gl156CWvXrgXww2vv6+vDoUOHIAaasQhTFLAmoXCrYEnbsswxJCO+tw6ISfMfjKwJAwMWAOit/h840LSi2+X/ePdR/8ePHARUmoFBq+coYIkHuo8ATieEqkPHqlsc+Jn54PW9/U1O7TX9a7U4gBkS/S6aB+f/Q8Kk7jvWyEvJxh0Fg+qHqtkxZs9BQBsNdWsH1K39H9qiQYAnnoM7iYMY4wZ4gHPqwLndYGoRjKnBQ+hfGC/hB1a3eCcgMi045gYzALyu/31k6O1/3YILGnUNpqTVYkraBxA90ejpzcKBmh+hvWd6UNOAGo3G7/Sdd/XGe/oumBYOgiCgs7NTDlvSGiep0uZdTfIOI/6qZL7b5gRblZJaQUhrrqTxDHfNle+0pG8A1Gg0il5gFLAmPt8dFPr6+sAYi5iAdeTIEcyYMQPXX389nnrqKVx66aV46aWXcNFFF8mv2+l0wul0yjtOTBQUsCahcKlgMcZQXV2N2tpazJ49G0ebpiCu9xC4QMHId1GSxOm/j1XAacXWOrldg0L3EcAcA/T4hDjRDSRMA1qUbRkAANZjAUuBg9gtQqw4eKzJaWZ/dcvkABeg5xbXVQ3GacAxZYjTe1rgVMdD51E+h0r0X/XipcapbQU/HOtTQVungrp7AbjOgh+qWzH9DU6ZUQBcGvB2V8DqFgT0X4VocEEUOaiOrd0S1QC0Pmu3GACPChzXBkuUAydYvgUHHZzOVDS3zcfXuxbBYExQLHIPVN3yXuTuXb0pKSkJuoWDVC2KiYnBjBkzBmx3I93udDoH/cXD37Y5I6lKeV9xCSjXXB0+fBjAD4t+B2u8GigAtrW1yUHSZDLJ07ATYd/E4ZoMAcu3giW1S5noU4SS7u5uaLVaXH755cjLy8PPfvYzrFu3Dj09PbjqqqsA9P8bcblcE26DawpYk4TvFOF4V7BcLheKiopgt9uxdOlSWK1WVGsycfRQE8xGK7Sxc6DqPgC4vK7G89dsFADaDgWoMLUC5tj+/3oTXAM3kZZYEwcGLCDw9KErwJ6F3r247H0Qyg/2V3k4gM/Kh8riAY8m8H3HttYR++A0TIOub2CIc/JR0ME3xAGBAifX538hP9dZAXBGqI/2QX30WHXLKMCdAAiJgBDNwDgG3mkAJ7jBVCIYx4N3M4imH56N49mxatex6paLgXcBArTgBU//InqNC0wDAD39ZwkuaNTVmGKowZTUDyB6YtDTm4Xamh+ho2eaHJQGCxT+FpWPpIWD73Y3Uv+uI0eOoKqqCi0tLXK4CbRwX3qcoapS3lOkx7PmKpiqnXcAnDFjBhwOBxoaGnDw4EEUFBQE3QtsIpkMAct3DVZPTw/UavWEW/AdSE9PDwwGAzo6OrBkyRK88cYbuOmmm3DNNdegt7cXN998M9xuN1wuF1WwSPhTq9XjWsHq7OzE3r17YbVaFRsQe2KiIHpU6PquAbzZDNEeB+P0GOgTALWnCVxXE2BLAjqVvaMgCkB8eoDAlDAwYAEBN5EeUNWS+HsMADh60P9i+r4u/724GCA6tBBrjgUpyzSoUmPhRhv6+jzw95Gn2LTaW2c5PNBCDeWUJ9fXiB7EwQzllCcn9qGdS0c0ftjOh7eroDugQvuhLESxGgix/dUtd7wA3m2EoOkPrXyfp//KRD/VLQb0bwlkdEFgHFROBs4eoLoFAB4OHHcUlig7Flp2A8zQf2Vi23zs/nox9Ib4ITu5ey8q927k6dvCwXttkj/e1aSuri7ExsZCo9EMqCYNNbXpryrl3Qcs2McJthWEd9UuUHDT6/WIi4tDQ0MD8vPz5YsJvPdNDKZjfrhijEV8wJJeo3fAktZfRUo1Uno9UkXuxBNPxObNm3HjjTfilltukZcNCIIAqzXAcpAwRQFrEhqvKULGGA4dOoTy8nJMnz4dmZmZysqaWg3V1AwI+8ugio+DWNsDe0Ur7BUAoIEmYRZMcfHQxFjAd9QqWyoEau8QaFFkX5f/422H0Z8WfKpDXc39vbXsHT4vSjy2ZkzZrgFA4F5c3pW27h4IZT3gARh1JjiTFkMVrYJKrAfn6K+CWdAKpo8H51BWsXiIYLbpgM80IQBoLYl+15QZtQCcAw7DLB4BoIH6CAf1EQ30MEI0CXDHM3gSBIgx/WvIOKcOnMcFUc0ADQfe3t/UVDj2yzTne2Wii4FzAQwacKIAqAGm84CpAaAXAjhAcEKjqUaaoQZpqe9D9MSitzcLtbVLUNQ9LahF7oFaOBw5cmRY29So1eoBVzgG06DU10gbnfoK1ApCel1DtYKQ1mB575sotcqQgpvvvomDBdJw4n0Zf6SSfk77C1gTnfSzv6WlBVlZWfJrdLvdmDdvHl5//XVcffXVuPHGG3HSSSeBMUYVLBKexnuK0OPxoKSkBEePHkVOTo7c88cbz/NAZgawvwyc+v+z999RkqTneSf6+8Klt+WrutqbaTMz3TODcSCpAUAJRksKlFZ7REoiRVBHq11yl7oyR9LKXEHkpa5EUUvgXl7uakkRl+eKhCRIIABJJEWCAAkS4AAz096b6vI+K70J990/sjI7M+OL6urBADODrvcc4EyniYyIyozvied93ucJXjSdtRq1xDDOTBNh7SNxPE8056DX58MB0yDb1anCopp5suttwFRYCL4nMx4EWABGCFWvMkAF2FBrwESrhl/J4c/O4QCt2AHEWAo9UiUeywUAFoBQO2hhNheVRqiR1hwyMoRo9TNypqwGNF1aTSdS02ktHSXl3cYbctrarRGJ8KL4UiI1D63p4kcBTcFuGaDZ4EcdfE2gNyVaQ+DrqNktXyLEOslsk6c77JYzyXrhSV599Rmi0eFuG2y3Fg6u63bF6bdu3cK27V1bL+zGoLQDAMPA305Gp48SB/RmrCB831cem2VZAcf8XuAWjUb7HOrfKabEvdWZKHscAFbvMX4nWDTAgzXp1KlTHD9+vMvqmqaJ7/vs37+fz3zmM/zQD/0Q/+2//TcAstns27W7b6reeb+avfqW17e7RVitVrlw4QKmafLyyy/vOGovDu0HwNtSgxN3tQ0ypO1RvbJO2040SfRAhti+MUy5hijO02WgGiW17xWy3cJTCddjITR0iGs5lZAW3tZim1mz+13d8Wyc7DRmcdBaAmTkgelopNGE+20A2BoZxrWepGXWyMaLGG77M0MDpp0iXuIQei3YNpXx6QDA2n5GeRgRdw18DWPNwlhrg0kv6eGOtv/n53xAtNktb5vdsgRaDaRFNzdRENRuCRsQBtL30QA/KtsaLip97NZU9B5Tk1/A94ap1Q5x7/57uFQ+1Kfd2ond6lgmSCm74vRB6wXbtkOd6SHcoHRlZYVbt27tOjYnbDuPqiULs6boFd0nEgk8z8NxnB2tIAZzEzuAtOMptttpyW9nPS4Aq8NAduo7BWB1jumnfuqnSCQS3d+vlBJN0/B9n0wmw2c/+1n+zt/5O7z66qvd7/q7pfYA1mNYuq7Tain6RN+CWllZ4fLly0xPT3P8+PEdL4a6ruMNDSEScbyNTbRkAr/aP3Un63X0kWG89d72l6A5W8KVaZxZ0NNHSR7LYCVq6OX7kAzxvTJDRL5OyLkphYRIl1cglmmDuf69bYM4heVE1fbIKTZVL6ygunTK9QWEZpDwHRwM3OGT6ONpfNZp2E2yBPet1IAgTwjN0iLKBlDpFi4RjIEeYsQvUxITZOSDIQO9qqNXdar3jpHX7+MOO21X+REJQkc04qA1Ea6D1FGzWxYIF6Tu4psC0ZRorW3tlqlgt6SPaK2RzDQ4m/xjkHFazhRrm6e77NbDAI4QomvhMD093We90Gg0uHnzZp/IfTcGpYMTjiqtVFjLbTdxQLth2yAYv1MqlVhYWMB1Xb7yla/s2gqiF5CCGrj1iuXfLrF1B2C9E8Det6q+03MIAZ588sm+f3f+np3vp2VZfOITn/i279dbUXsA6zGp3ouQYRjUaiHWBm9R+b7PzZs3WVxc5KmnnmJsbOyh79F1HV/6xI4dpXnhEvroSABgAeiZ9ADAapfYppi9covS69uAShsleTZPJH8Ww1lBVHpahrWQFl5hASk0xKA7fKPSnjIsK6b0suMKgAUYatYgo6sZxHhrCyJJaPVH/Qgk2vD+bcZNIDcKuBttFksbO4ydnGybnDr3EfYWAEmtDAoJWtxfR0aGEa3+c6jh4WdOQulK4D2JVB7KwSnOhFZGeAJz1cJc7bBbLu6oizsGfraH3XJtfLPNbokWCJ+u95aK3dJskELHFz66K5ARBtitJqZ5m33RO23tljdMrXaQe7PPc/nyoUAuoKp6J++q1SpDQ0Pous7m5iYzMzO7NigNm3B8MxqwQS1Zx8LhUYxOO6J7z/Oo1+ucPXv2TVlBgBq4bW5uMjc315cruZOh7LeiOgL3xw1g1ev17wgGq1OdY5RSsrS0RLPZxDRNIpEIlmVhGEZ3anKn1IJ3Yu0BrMewvtUi92azyYULF3Bdl5deemnXF4NO5lTk+BGaFy4hQi7UMmTfpQo0+pLarU2q1RpgYY6dInEwhmWV0Ir31S08txWuw0oOqQFWiBYqzLxUq6xCNBnITBQA+SlYvhn8hBCtl1kt4q0Wtk1OTRqpw0SnMkStMtKMIBpBdksm9gUAFoDmq01Y9do9tU+Xv4WXPIJefdBq1asGehVqM8fJ6TP97JblI2o5hKi3reN9QtktD9Acr+0cj4+wtz22Qtgt7DWSmRpPp76O8GO0nCnWC6d57dVzmAParbALdSfGZ9CgdGZmhqtXr5LJZLqgJKxVFjbhWCgUuhqwTsttaGhoRw1YR0s2yLbt1ui0I3IftILoTBQuLS09khVEmIdXoVDg8uXL3dzEh+nS3or6Tp8ghO/cHMLe0nWd3/u93+Nzn/scr732GtC28em0uBOJBKZpYhgGn/70p99VgHoPYD2G9a10ct/c3OTixYsMDw9z+vTpR7rj0HUd3/exjh0BwCuphevumhq0OCurYBrg9B+brNbQh/J4mwWc1SrF1Tao0SL7ST6zDytVxKjPQaPYfY8Ic4cfDIPuVJipaXkNP5pGawaPRWYmEE2FY32Iq3uoYL8vX1EQq9TgRq3d6DtwCkcO4RhlcpFNNG8b0LnqMGxRuYOvxdD8fn8v4TWwE8exareCbzLU7a+UUUM4AnPFwlyxkEj8pIc73sId3Wa3pIbWssDdDqg2BXigN8CLg2/txG5p+KZEbwnQ2nGLUtS2fbfa7NZU9A5Tk5/H90ao1Q5xf+45LhX7tVu7MSgFugalHa+r3RqLDrJSvRqwe/fuYVlWdzsPi98ZNDrt7E+Y0anKyV0VT9Rr4Oq67q7am6D28CoUCl1d2m71ZG+mHleA9Z3WIvza177GD/7gD1KpVHjqqaf4+te/zsjISDcTtFarYRgGpmm+q8AV7AGsx7K+FQyWlJKZmRnu3r3LE088wb59+x75x9DZL3P/fkQ0gre+gYjFkI3+xV7WHgCm3hK+jzE5iTMftEbQc9nA6/2WS3NDp3y7CKSIHpgmvs/EZAMxOF3YqZ1AjiorESiLOFmCAKtcraEaOnY2FlEu1bUtGmaamKPYlm+hgoSNjQKx2hom0CKBNnUEfTiCW1tAJ4I5oLcS+BTlEDmC7F2tVkPFoWnVGaQIxvaYzjpe4jB67d72tkWb3bpjULt3iJx2F3fExR1x8EaBiI9WzYGsI/UOUxbCbhmg1X1AR+oewhPtSCEluyXBXSOpV3ky9XWEH6Vp72OzeIZvfP1prEhbu+U4zo5ZZyqD0g7Y6m2VdTROYaxUmAbszcTvPGx/IpEInuftGJmzWyuIh00U9np4dfRkHXarV0/WAYE76cl2U48rwPpOYrBarRb/5J/8E2zb5r/8l//Ck08+yejoKH/v7/09/uJf/Iv85m/+Jj/90z/Nyy+/zL/8l//y7d7dR649gPWY1LfSpsFxHC5dukS1WuX5559/014lHYAldB3ryGFaV69jjI3g3J8LvlYBmAC0WEhLImQ6zOtqvNpC+ebs9nayJu7QEUYmDMzqHHTCpxvlkKlE2rE5CoCVSqegEQRmcU+tgzPtMjKRRyi2pWdGYSMIsCyhBgaR2hpStxBeu/XnL67gb+NPe/p5SNpo0Tpa8y7Ca7dKk4kkKAiudv6hYmLRrdKMHiLaVBi9muqFIKWXEY6GuWxhLm+zWykPd6zZ1m4lffA1RNNCeC18k66tg1Zv2z/4SQCvzXwF2C2Bbwk0py2k96MgY/Uuu2WZt5iM3WZy4je2tVuHqZXPcutWnY2NjT4QoKowY9HNzU3m5+e7rukdoBQmBH8zrNRu96dQKLC4uEij0eArX/nKro1Ow6wgHnWi0DCMQG5iWAB3LpcLPbawelwBVr1eZ3R09G3ao7e2SqUSv//7v88P//AP8773vY/FxfbFKRqNMjo6yo/8yI/w1FNP8dJLL/HBD36QH/qhH3qb9/jRag9gPUYlhEBK+ZbaNJTLZc6fP08ymeSll176piaKOhosgMixI7SuXkeY6u2FjdP7DXV0jasAYwDe6irCMpF2v7bILzZwvCSbd6ugjbY9t0YkhrOMSOZDWoLqhUavbSkfN5ulUNZLZMaUj1tGiGt3bR00I9DC1PBhaFppR6G5Gu71+wD4Ik0rv4/kVApDFpWMlCZbuMljGNVgW7Pl+KigrVa9j0RDDKjtTWezT7slEOgVA71iULt7kKxxD2/E7fpuYUloJNEcB3Rn26g0hN2yQDQlODrgtV/m88CFfoDdEu46CaPC2dOvIvwIjrOf9a0zvPaNpzGtoV2J0weNRTsGpfPz8wF262HxOypW6v79+7tmyTr7MzExAcDS0hJHjx4NGJ3uxsV9N1YQuwGAYXqyQqHQ1bcNTjk+jN16XAHWdxKDVS6XsW2bs2fPAnSHr3r/9ocOHeJ7vud7+NSnPrUHsPbqnV9vVYuwE7lx+PBhDh8+/E33x3uZta4Oq1pRvlbFXgG4K6ugaQEHd79YQsuk8Qd1Xb7EGBtVthW9qAWV9mtqNzap3QCIED09RCz1HKZZbAvlO6AmEPq8XdWNEBsH2myYAkgxOMHYqa0QqwjfgeGDsHE/+FyYHUVPu1OTkthmCW+zhAf4+16gIQtYiToJltDbsdVIXb2ttCgojU2FW6YZPUi0qdgvXc0OpfUiwtExlzTMpW12K+PhDju4kwI/PsBudbRbAM62sWkCwO2DdaIl0ZxtdisiEBK0Bkhdg0gTBEjPxnRvMRW7zdTkZ7fZrSPMLj7HlSuHupYJHe2W6jvf65p+5MgRbNvuxuZcvHgRePT4naNHjwbid3qzBYeGhpQ3Nx1PoV6jU8dxukzSoxidQvhEYW/+4m5yHAeZu2az2d2n3UYLPa4A6ztBg9VpWdu2TTqd7t4wO46DYRisrT24gdV1HcuymJ2dfbt2903XHsB6DKsDZHbSZexUnudx7do11tbWOHfu3Ftm/tYL/KyD+8Ew8FbWQhimElo6hV8eAGCuizE+gbscbMkZQ3lshXBehEw6CU8NcuyFIs3t7WiR/SSOZ4nkHCjfw9NjRLwgi1bW4qQJAqxGs4FqOfO3llAuHa0azWiOaDPIitVdlP5WztaqWtNVL4ZrugoNsvX2ZzS1EcwDk5D00Rw14BVuJdTYtOmgZrdqs0p2y3CLeKlj6JU2UyYQ6CUDvWRQm+mwWw7uSA+71YqiNSXozrYgXsFuRcCLAF47KxENpCaRugdCxW6BcDdIGSVOp15D801azjQbW2d4/bVz6MYDsLUTu9WZTHxY/E4HlOw2fmcwWzCVSvWBG03TugCrt0zTDLi4Dxqd9vqJhR1XWFvyzVhBRKPRh0YLdbbVmXJ8XAFWvV5/1wOsTpmmycjICJcuXQLav5UDBw7wpS99ib/7d/8upmly69YtXn31Vd773ve+zXv76LUHsB6j6m0RAoEQ0d1UvV7n/Pnz6LrOe9/73rd0DLu3RShME+vQAezbdzHGxnDmg6JrfXgoCLAALZWAoGUT6CG2Dw21oN2q1pWP+6Vylw3zWy6Vyxu09yJP9On9iGyjLZTvcZQ3w1ikqrp9qDUruLEsRs9kY6e8SAoUAEs21ZOBZn0TP5JEawWfN7KjsB4EWEnjAejRfB9vpn3+PSTV0XNE8xpSbBD15rsASZrqycu0VgQFYSrcMq3oQSIKdktq6vOVYR1sC3NRw1yMtNmtnIeXdbGnBTLhg6+r2S0Jer0NsmTK7zzU3pdBdkuw7dWl4Uck6B6eJzHNW0xGbzM58VmkN0S1dpz7i89y+fKBPnbrzcTv9NocdLazE7s1mC3YATe92+kAkbDayej05s2bu44VguBE4TdjBaFi3AqFAteuXcPzvK7Yfifn/e+E8n0/MFTwneDk3vkOjY6O8oEPfIDNzXayxL59+/ihH/ohfuqnfooPfvCDPP300/zn//yfabVafN/3fd/buctvqvYA1mNYnR+s6u5op1pdXeXy5ctMTU1x4sSJt/zusWPT0Cnr6BHs23cRIcJ1EQKYcBzlw4H2YOflq+q2om7bkM1AMcg8GcMqNkzg1y0KF9stDpE4jD8uyI1IYrp6n2JOGaIpaAaBopEd77OO6FQiota5JFpboJv9YdLbpeUmYSVosWCGiOON8oraIwxBveITWWu3Kmv6OGLfCFZWIFy1/k1zivjx/Wj14LBCwwYVhNBDJhN1v4aXPgnl69t7I9C3DPQtg9rsfjLm/X52y5SIVgzR8hDSbcf2KABCl91CImoSpAm4+KYHut/58AF2a5OU8XXOZL6B5um0WgfYKJ7mjdfOoZvZPu1W2OTdYGxOh7lZXl7uAyUP00rttJ1ms8mrr766K3CzG6PT3VhKqKwgekHSo1hBDDJuHRPX5eVl6vU6X/3qV3d1rt+N5bpuAGR/J7QIOxmZyWSSn/zJn+z+LePxOD/2Yz/G9evX+dKXvsTrr79OMpnkb//tv82P/diPvd27/cj1nfNN3KtdlxACIQSu6+5KlO77Prdv32Zubo4zZ850xbNvdQ1qwyJHD1MlnGHySup2lbum1kK5axuIaATZHIjCcVyM8bG2fmugRDqFVAAsQhaoXhAnaw7iLhTvApokefp5tEQNGvPE3R5wlp2AFcWxhLVvw6wipAf5aVi/r9jfECBdWEQKgVAxAfkpWAkK2rWekGrd82B2BXcWwKc+dhZryMA0C2iN+w/YLSsHCoCVNkqg8DYVXo1m7AjRhiIrMmSYIOMvI+045kITcyGCFBIv5+LlXJwpEz9tg6ejNS3wtycTzZ5ttUDzOvotZ0d2Cwk4GtIwkaaNJ8E0bjIZu7XNbuWp1k4wu/wsV64c6GOBdorf6dgcDIKSRw2F7mxH13WKxSJjY2N9DNBuXO53a3T6MONVUIOkN2sF0ZlyFEJQKpWYmJgIBF7vZp/eDaXqMnwniNw7AF/XdU6ePMnJkye7z+3fv59//+//Pffu3aNYLHL8+PF37fHuAazHqDoXGiHEroXurVaLixcv0mq1eOmll76lX/TeFiGAdeQQCNE2EFUwTN7auhIwyXodfXgIbyMoHjdGR3Dmgu1GLZUEBcCSIQHIzY1NpUbKXVvHNwy0QRsMX1Be99EuV4AsjfF9JA/GMc0ivhTqH2JZbahKq4YTH8KsBwObbUylV5VfXldrutwWjUiuHdEzUM2Wq9ROJVoFfARa4NxoVEs+udV5bMCzJtGmhrEyPrhqkKzZW/jxfWj14N8k7PO1yl2kFkH4/X93DQcv/QSULgMgpMAomBgFk9bMJElzAXfUaTNcwxIMibCjYPsIz8FPtAHUYPWyWzgSWY+j08C3PDC3j0v4247zbLNbBVLGH3Mm8wbC97DtA2xsPcX5N86i6f3arZ3idx6mlXqYO31ngR7cTqFQYG1tjdu3b+9ac7WTpcSjGK8OWkF0wqVVVhA75UF2jq13yrFj4looFPr26e3OTXyz5brud1xUzs2bN3n99dfJ5XJYloVlWUQiESKRCNFotPtYPp9nfHwcaDu7v9v+drAHsB7b2o2be2fqKZ/P88wzz3zLqffBFqEWj2FOTeIsLGJMjOEuBwGQMTqKMzcf3FY2owRYIkTTIsPOhULjBSC2ShCJgCI0W+azoHCbb/peV4TurFTZWmlrolqZGMmx02TGNYz6/IO2YHUdx4hhKlpvdRFRmpS2KoUQM9ANPCuBbge9t0Q8CwqA5VfVAM/AoxLJk2opzm/Pf+u2AzPLOIDEpz7+NJEhA8PYQG88mAiSVh4UACujF5VZikK2aMaOEa0rXPB9dZsy5S/hODms+RLMb7Nbebcd45NP4ucLSEdDa5gIabe1W72WGD36LdL1rqSsn93avokR27ZrItYW0GsCQ7/DROQuE+OfRXo5qvWTzC0/w5UrB3YFJnbSSu0ULj04yNK7nd4YnzcTLr2T0emjTBTuNlx6ELipRO6xWIx9+/b1TTkWCoW+3MTBQYB3cqmO8d3aIuwcy2c+8xn+0T/6R12/RNM0icfj5HK5rk44FothWRaxWIxUKkWtVuPHfuzH+LN/9s++zUfxaLUHsB7T2onBklJy//597ty5w/Hjx9m/f/+3hWZX7ZN17AjOwiJaMgkoWng7TCapSjZDfLI2gmwQAMUyIh5D1geiYwBzTM2GxbIZbAXAShmmSutNpNzAbZhs3HKAFOb0FG6qQSZew0omYT3YJkulkqDwKU065XbUjsLmQc9PKXVYMVPNWMSdCrYewfKCINIJEaHHbHWAtkCjVvQxVxba7FZsP9rkEFbKAU/NbgmnFKrdajWb4eyWkUK4/cBYAHr6IBTbNglCCoxNE2PTpE6WRNTrZ7d0iWhFEZ7A95sITeAlHsJueSDrCXS/ih8RSKve87pedmuLlPFVTqdf58xxH8eeZGPrLBfOP4PQsn1gIuymZlArNdhy64RL27a9I4hQaa46hqlvJlz6YROFD7OmgN1bQTQajR1v+nr3qWOX0TsI4Pt+H7u1kz3F21We5/Udo+/779opws4a8uyzz/KjP/qjWJbV9cGan5/vRuRMTEywsrJCq9Wi1WohpWRra4s/8Sf+xNt8BI9eewDrMa0wN3fHcbhy5QqlUon3vOc9ZLPZb+s+BQDW0cPUvvQHoQyT31BP+nlb6uk8Z2VN2W6UlSpaNoOvErSPDuPcD7JkIhrChoVpxtY2lJ+NpMeLS+DMt8FBkQjWyUmaLRge19AqsxjbYcxaVQ0IhedAbgq2gr5e6CE/963256Joh9bNDJYXNFWNaWpwHvGb1M00cYX1g+zht/RGC+4ubbNbksbkWay8jqmtoDUf7HuodksUlBYPAknTmiLq3gjuXEt9zuJsUXeniM8tw1wPuzXq4KUTkG8ifQ2taYLfxLdEP7sFD/y3UtVtEC3D2S0DpIwihI4vPHRtlvGxWcbHPof0MlTrp5hffoarVw8+crh0b8utA5Q8z8O27YeyUr2aq0EX946+qTfqJoxtA/VE4ZsxOt0JuG1stG9iHMfZlRWEahBgMDdxN63Sb2d5ntd3bur17bSFdzHA+uAHP8gHPvABpJQ4jkMikeCLX/wi//1//9/zkz/5k/z9v//3mZ2d7T7vOA6VSoVDhw69zUfw6LUHsB6j6r0YqtzcK5UK58+fJxaL8fLLL3/be96DGiwA8/AR3IkzaF6tLfoeEGO7IYDJ29xCSyTwawMAbAdBu5HPYSsAVsv3lfolr6Zmw5zVNbVw3HXRxkbwV4Mi/DAvLm+ribbiULgHUoyTOJ4nNiow7EVkSIi0H0kq91dWi2p5uNPAS42iV4JASoYET0cbBeWUH0DLiCsBVtRVRwMJBLWCh7G0TAtwE4cwpnKY8SYi7D1eDS95GL16L/j5zbKS3dIbC/jRMbRm8G8fSQ5Dse3t0ctuuRgQz+OP1HFHXLxhQPMRrSh4BlLUEK5AxsS2OP5BBditpoXmtkAXyFizC2elQQ+7VSJlfI1T6dc5fRwce5LNrae5dPFZJOk+7dZO4dKdlpumabRaLTKZTICVepigPMzFfXNzk5mZmV1H3QxaU3wzRqe9wO369fYkaTQafWQrCFVu4qA9RW8k0E5g8ltZg5PeHafzd7MGSwjR/a501phIJEKr1WJqagohBAcPHnwb9/Ctqz2A9ZjWIFu0uLjItWvXOHjwIEePHn1bLiYdDVavbsQcyrB6zaC5JEifOEdq1CUWr8H6ArLVahuLTowHjEWFAH1kGL8WZD/CBO1hPllOqaK0EnBWVhEoZtpsByeVwKoEwUHF81BdGqtbW0rtlLu6htQEmi8REuo3C9RvAkRp7BslPwypVLPPUb5SKir1WZSW8DUTzQ/aOJRdjZziLZarZgiF71IQQ+QJskKmrv7uxNwqTSNOVLFNvwfIGbU63Krj0JZg+dPPEMlJDLmE1nrwd5NGSvk5abmGFBZCBscTW/oQMUWrWavOKp3oDWwq7mFSs/ewZtvGpB12y837CCOCjLtoLQNkS81uAVoLpNnaBmHb7JYNUhtgt0yQukC4BhIfPTrP2Nh9xkY/B36Wav0J5pef5erVA6TTD7RbO03LWZbF9PR0YBKwIyjfzYQjBFt3ne30Rt10trNT1I1KvF8oFB7Z6FRKSTwe5+DBg9+0FUSYPUWhUHhLchPfbA0CrGq1imVZ37bP/1ZXR5dVr9dxXbcLHB/VQuidWnsA6zGtTovQ8zxu3LjBysoKZ8+eZWRk5G3dJyllQJibfmqK5lIZInEWv9L2XxLmPobPJEiPOYiYDwrndmGpv96h7cYQQXukVlOyZJrnoY8Ot1t/AxUfGcFVAKxESAvDKKtNQoWUtFJJoorn40aWxoU5GrQd5Y2DcfxIibSm8D2gDQRFfkodpxMyLZlwyria1W1N9taNGZeXDyre46rPI0DDTCsBlhXCVGlAZd3BmF/DA7z0EfSJLGasirCLyvcI6eKljqNXgnozr6628BBumao2QdIPOtTGI3rXSkL4AmPDxNhoL3CtZBIxtNFuJw6xzW7FEJ6J1KpIAZortt3lH9Qgu0Wz/f3SfPDj9Ou3tv9PuEWSxh9zMvUap47rOPY4m8VzXLr4DJK0Ugg++FsanARUBTB3trGTBkzTtO5roB110zu9p2la33bC2PAw0X2hUHio0emgADzML6tXl9YL3Hayghi0p+jowDpgspMJmc/ndxTwfzMlpVQyWO/G9mBYdc5bq9XCdd2u8P3dbK3RW3sA6zGqwRZhx4AQ4OWXX37bRZ6dC8mg7iDz9CRrv3WdXhAgHcn6+SrrQPLUKFrjNLkjGpYs4K8ugZTIqnrRDgt+dlfXEZaFtAfAhOuFTjHq6bQSYGkhFwitWlMNxqHZNvpwXjn56Frqu1XdtulARb/lYt8sA4ICFvFTzxPNukhnGau+/IBli6hbCzFHDfAA6laGdDMITBKmWoclmlXqepa4Vwzuc8hdacKpYOtRLIXgvZfd0stVKFfb7JauIaefJZLx0b05NLuHTdPULdekXMc3UmgKEOgoeUrQKneQRhLhBs9Ryx4nPVvFmo222a2hbXZrtAZODBF1QQi0eqttARHC7gnp4SUEUttmt1oK7Za57X/qgXB9tOgqY6OfZWz4N5AyS61+nPnl93DtWpvdyufztFqtHdMWelmpXiBx7949rl69umtPqWg02jdR2NFc9U7v7Sbs+lGMTl3X3bEF2NGldYCbirnbjZ6s1+oBHuQmdjIhYfeRQI9SnYnq3t/Mu92iAejrUnieh2maNBptuUXn2L5THPr3ANZjWrZts7GxwdTUFCdPnnxHjCt39qHzo+tU5qkpAJqrahDQXCjjlpuUZwAiWLljDJ+OEjcaiFgZ2ejXSslyRR38DPi5DEKhkSKsvRByIfC2isrH/VIZLZXErwSPRc+EWEuEZCK6q2ug6xCYBhU4jQj1ayuAiZY6Sup4FitRaxuDKirq1mjpUSIKgLNViZBWYLzDw3V8CZpiXbp8z+eFA8HHUwQnEjvVFtQHPz/iqNuUmudTXHXQ76/iouPmjmOMp7AiJUQrJHgbkIn9ULoaeDzmh7BbSLzEQfTSlcBzSYoPXucLjHUTY92Eq1DNTmBlZ9rsVl6C1plMNJFaDRkRaPU2aPKTdNuTg+yWaEqQEaRsoQkNP+oiIwAOPqKH3fo6J1OvcfK4hWuPsVk8y8LWOTw/2ScED2sv9QKJY8eOKX2uelmpsO0Mhl2/2YnCMKPTQqHA3bt3qdfrNBoNXNd9KADcjRXEbo4N+nMTewX8j6oDe1h1JByDLcJ3O4PVez46/91hEzsm1t8J7UHYA1iPXUkpuXPnDuvr62SzWU6fPv1271K3NE1DCBHITosdyGFkotirFcxMDKfUD5jccpPIeIrWthu6veWy9IdtAJM4dppYokV6zEWrruBvTxeGBT83pK8MTK4Ui8pQ5ubamloAX9jCs8y2F9Tge2JRLAXAarZaym1ZdbWYHs/HzqSwFI72lXq9K/T2Kzal17cF7FETL3cEM++SNLb6HOWbZloJsMobW6Aw709FfGY2oxwaUkxNhjD8orqBrSewPIUfV8hFNe6WQ+0iHkwmCoytEmyV2jYQpoHc/zzRZAvDvY9w1PYRvRWlhm2OYjlBsb9rN1HtnWZvhFpJULOwilGs+9vs1rCDO+rijtSQpkDU4yAchGMjNdTslt4Wwfuuj0iC3/LRmtvaLUvBbuEjbAdTbzKZ+Q0mnvrP1JpHqTvPc3/hSa5fF31s0k5aqTCfq/v373Pt2rU+n6udthOWUfioE4W97c1jx47xjW98g0QiQblcfmRTUZWerNPefBQPrzABf6FQ6PMn63XN3237qwOwes/Hd0IO4S/90i9h2zapVIpoNEo2m+VrX/saQHdwAdpAtmNAaprmntHoXr2zy7ZtXnvtNRqNBvv376elMMl8u0tl1SCEIPPUJJtfuUd0KhMAWACR0QcAq7eMRJSNC5u0m3gZUgfGyR3VMSyUU4mpSFTpVRUNOVdapYaIxQIsGYA2lAdFW1GGLCBusaQUupstG5mIIwYnItkW7CsAlqEAdgA0HbxSDH3ZoUyWrfQQ2rggFquSyQ/DUhBcHBluhjJVW60ohwgCrKm02qoC4PJ9jWeng4+n9fBQ4jC7iIiibQegOy7FpRZGYwWXCO7QE5jjCUyjgFCYmnbKs4ZBAbDMxj1cTAyC59W3ckqAlXDmu55cwhcYaxbGWvsvXMntw8rewR118fI+CIFoRRCuj9S3GSp/29w0ASLS/lwVuyVJgl7DqAnMAmgtFzcWwU+8jG3PkTJvkjZvMHYoim39KMuVD1EoFJmfn0cI0ccmhS1ivXYJR48e7bbJOm3AR9FcqTIK38xEoRCC4eFhRkdHlaaiuwVJg3qyVqvV1ZP1Mm67aQGGRQJtbGxw586dbiTQbnITO/qr3v1+N2uwOm3BH//xH8cJyYv9C3/hL3RNRjsAKx6P47ouX/7yl0mn1YHy79TaA1iPUfm+TywW49y5cywtLXU9Vd5JFWaAmn5qis2v3EMLMcUMK6/ZK2gXVGabVGbbrJhXPErmhAHaBolmEc128EIMR0W1jpZK4VcUYGZ0GGc26JMVSSWxFQAroWuoZPZWtYawTKQCHOlD+aDlBBCzIoolH4xyOaR9CE4s0mXF9LIHZWgSxZmKEcmew7fqyMosuUgbJMVNj3ubUQ4rmCpNhbqAfVmbQt0gHw8eqe2FtExKK7h6BMMPglkR4uEVd6qhrc0HOg6BsbmF3Nxqs1uRDBw4SSRew2jdQ/SwaZoX0o7Ex00cgVrQPV7Wg8L49qf6eIkDytaiVSpjbUWxZqJIXbYd5UfaDJeM+YhaEiFdpGa3RylD2C0/AVqxgTEfI9KNIxKYjTlkYx1kDE1LINOHwNKwnF9jf/I6kxP/T3ypd9tb8/PzjwRKettkKs3VbrcTFgfU600VFgfUK3IfNBUNa0vuBiRFIpFAC7BQKLC0tMSNGzdIJBK7toLo9Sd71CxH1STdu5nB6hzbJz/5Sba2tqjX61SrVSqVCo1Gg3q9TqlUolarUa/XqdfrbG1tsbKywtbW1rsyxPvdt8d79aYrFotx5swZYGcn97ezVF5YAJmzbR2WvaVeAFtraiajsVhUPz6/hTB01r/eBJKs60mGTidID/voXhF/aSnwHn04rwRYofE7TTWL466GGI6ynZW4EPxsDDWw9ApqQ1U8X2lfAf2Gn31vWS1QW/K3/btGuKrrbHgNpsbrtEQUFExVPhrSvgTWmkny8WLg8aF4yJSjgKsLJk9PBgGWSgPWqUZIazPmqKcZ9VaLrfkGucYaDkm80QNYo1Fce554c0GZcwigm2o2xbTXqJMl3qPH6pavnliN+GW85BH06l2EJzBXLczVNutTzYxg5ufwxly8nA8IhG0hHAff1MFq/z5EC6JLAqMmaehHgX4gJ2jg+ENERAG2QZ5E4sXuI5xP4uT/5o5aqQ671QEAO7Fbu9Vc7bQdVRxQZzuqOCBVjEz3/Ia0JTsgabdtyTDGrTc4e3DKMaweluXYYdI62woDWO9WBqtT/+P/+D8+9DWdCUrXdXFdl2azueO5fafWHsB6jGpwXPthWYRvRw3mEXYqeXwELWrQmN9Cixr4zf59b62UMdIR3HL/wuhVWkQm0rSWB/RWPvh5E7GyDeY82LxUY/MSyAN5rFaU7GEdiwKR8hb4Pk3HUepw3Joa3Dmr60gUciTXheE8KATtfsji44ewjX6xhB+JoKkyEWPq6TGjpQY4uB73ywaH0i4gGPJ8hojASoSbmwYbaZP0cIvjY2USZps3259tUm7qpKNBUFxtqhetQ0MNWq4gYgQHBGq2+j1yawmpqz280NTgM+rVaRoJpcFpxyBVAMbaJv4aaGhUY1OI/VNE4yX01j2E9wBAimawddgpPTkF1WJw10KCqQEw1ExEorSOXRohPlN9wG6NOrgjEqI2OBZmIU5krYqQYvtY7yJFHCH7vydJfYGiM03WnN8+XoHRmIXGLNI4hpv5/u5rw9zXFxYWuH79+q4nAXeznd3kARqGwejoKKOjo8o4IICFhQV83yeXy4UKo3fbluzVSYXVW2UFAUGN2yCbGI1Gu276HRD4ZkTuf/AHf8DP/uzP8vrrr7O8vMxnP/tZPvrRjz7SNgbrP/2n/8Qv/uIvcuHCBVqtFqdPn+af/JN/wgc/+MFvarudEkJgGEb3/L1bQeUewHpMS+Xk/k6oMGZNM3TSZyYpvjZHbH+O2q3gxFdsKkulrHDpHk4EARaQHs1RWQm2dyzLwpmtsb7iAmnMVI7YIYleb5KLRmGAmXJW2kL3wHLTsnFTSUyFoL0OoWJ61eP+2iZC5Q4PuKkElgJghW0rUq2BYbSB3kDVsEDRwByNwLRpQMmgWIxz2fFx4w6HJus0fJN0NMikRUImBk0d7pdTHEwr/iYKoAZt/deVRYszE0GAlbFon1BFNYykEmAlWmrRu9FoUpirozc2sEUGf/wI5rCJySpacwk/MozWCtpyGEJ9syJwKMopsgSji0RdwVSynZuYPQzFSwF2y0npCNPFKAj8+EH8/ChYNTT3Ll70FEbjfGB7UUPNpFqrP4sXfxFpjgb3YUC8bdt2V5d06dIlpJS7ngQc3E5vHqCUsstK7dS6U8UBffWrX0UIwa1bt2i1Wl0maWhoaMeQ6jCj07W1NW7fvr1ro9O30gpikAW0bZuZmRnW1ta4cuUKv/Vbv8WFCxdwXZcTJ04otxFWtVqNp59+mo997GNvWVjyH/zBH/An/+Sf5Gd+5mfIZrP8yq/8Ct/3fd/Hq6++yrlz596Sz/hOqD2A9ZhVJ6383dYihLYfVvG1OfR4SIshEvJ1DrmoyVbIYl7tf9ypeDiXACNKSZsieyJGZsLHLy+il0vono8xOoyrMhwdHcFRAKxUMqm0ZIiHsEua76OPjuCtBYFlMp/DVmzLCMlEFNA2SF0Ktg/DbCemEi51VxA3JLoQHLR0cHWYi3J1Q2c+F2FszObYSBFTazOQh4YaoeL45QIcVOhVD+XD31NuhRjHFpeRmoWmMEMVIeyIKW1qZoaEYrrQ3G43CinRl9fxl2lH+CQPI/ZPEI2PoDfvIno+T6veRwoDIYNAK5bIQDUIsNoTiPvQFKJ7YQfBJ4BZ8dhimhwLaPVNqLc1g1KLwRC4iWfRxBKa++DGISrW8SIn0VvX+7YlZIOt6z/Feux/7eqJwsCEZVkPzRbsZbfCWClVHmCvxUEikdhV667DbBw6dIhEIkGj0egCwEcxTN2t0Wlnn3YCbmFWEJ3Jy0exgrAsi2QySaPR4Omnn+5Oaf7bf/tvefXVV/na177GBz/4QT74wQ/yyiuv7Ng++/CHP8yHP/zh0OdbrRb/4B/8A37913+dYrHImTNn+Of//J/zyiuvhL7n53/+5/v+/TM/8zN87nOf4wtf+MIewOqpPYD1mJZhGO+qFiE80GG5FTUz4hbVeqBH1We1lsvoSQuvOmg46hM9mKdwuUDhMkCe2NQ4wycs9IzfbvkN7HvoSHY1xNizVkdLp5Su8no6pQRYsqk+H1ajiWca6E7w7yxC2iAZXT3dowlYtSMcUrAhCaFzUrdgw2JxLcG862NlbI5NVijXDSYTwWM19RDneMtnsZpgKhlknZJWCCAGLi+aPDkRBFgZI3wy0TZiSoCVsIt4QkcfyFk0qjWK9yrozQItfQg5MYKV1zH8BTR7vaupGizTCQLvThUbBnnF43r9PtLMIpxi4Ll0KgEDXw/huxjrt3GqB9AaFfzEQWRuhLq7RsJcAqW9LUxGXqXozXHjxlqfxmmnVtluWKndCMp78wAfNlE4NDQUMEztaLCEEF3bhUG/rEc1TN3J6LQXuHUic3ZqAe7GCmInN3jf97tThGfPnuXs2bOsrKxw8uRJzp49y2//9m/z4z/+43ziE5/g+7//+0P24uH1Ez/xE1y7do1Pf/rTTE5O8tnPfpYPfehDXL58mWPHju1qG77vU6lUupOYe9WuPYD1mFaHwRqM0ni7aydmLXV6AmFo1OcKCFNDOv2LRn2uEKrPkjEd0ejfrle1IW9BIbgwayPxIMACtFQ/e9ZYtJlftEk/OUH17gEih3xGJjTM8hqyVsMrq5kIb6OAiEaU4EjP59SxPSHskrOunnwEsBNxYsXgPpS26spMxKmES80RJMzgZ5WaQtnXnEo+ON9RTXDM0qERw74b5RtbGtlckoP7W0wni2iivd3JTLhFyMKmzpRCcqH029quSitkurS8im9E0VzFBGRIPJCGpGJlSbWC5zW6bQuheT4srOItgIfAzRxFMyaIxHX0xr0+JktrreFHRtAU5qfJiK+aHQDAi09jlIrB/avcRWpRhB98Y6UpyQNabQNqG6QAX0vAUAQ3+QKavI/mPWijC3yOZ7/GgRP/oKsn6m2V9U7L7cRuPYyV6mxnJ1YqbKKwk1EYj8f72C3f95XXrkG/LJVhqipWaLAeZnT6sCnAvr/ZDlYQvW7wvS3XMJH78PAwH/3oR/noRz/ajRZ7szU3N8ev/MqvMDc3x+TkJAB/+2//bX7rt36LX/mVX+FnfuZndrWdf/kv/yXVapX/4X/4H970vnwn1h7Aesyq0yI0DAMpZfcu6Z1SOwEsPWKQOjlG+fIyscND1O8NLIA+xKZz1G4rFrL9eWo3g4+b+TiOAmC1pKM0/SxvldSPLxWgAY1rGnPXADFC7uQhon4DkWgSVQjhG7EoUQXAqjQaqOTp9fUN9Q+20cCJxzAVhqReyPRhaX4D1bS3JmChanAip7CKkOq/Sy7is9bQGY0FHeVN1+IEEuYs7rpJlqRHasjmxHiRYssiGwkR3CsqFXFZrccYiwePcyQbMgUGXJ7TeWoy+FxaC/EKA1xN3YZuO97HiHi9+yAwShUqDRPNLtHUR2FyBCsHhjeH5mwho+OgAFhmcx6px/rE9J2qljfJKo/JxUseQy9fDzyX0wpIX++K+AE034X1e7QaZzCqVfzEIWR+GMwqmnMHo/yb2CM/QTKZ7dMTbW1tsbm5yY0bNx6J3Qpjpa5cuYLv+31AIizGZzcThQCrq6uMjY3tKEwPM0ydnZ3ti/F5WK5gGHDrsFKPYnSqsoIYbLlqmoZlWX3TkoM2DUKIb+oG+fLly3iex/Hjx/seb7Va3WnHXoH5X/pLf4n/4//4P/pe+2u/9mt8/OMf53Of+xyjo0E93+NcewDrMa3e3L93EsDSNC20RQiQObeP8uVlzLT6wqwn1Bc1PRayYEZjOIrx+qQRpU6wTWVUfXWzZbOFHjfx6tuLthRsXWu/P3r4OFqjTv4Jk6hRxl9ZAM/DSiZhK9iiMsIAZrkClgWDWYmAHY0oAVYmnsAjKECfTHjUPY24wtxTi8dA4a41qvC06lTBtRgl+PljPTqrlCE4gQFlg2Ipxmtlwf4DPqPpIlOpBwB0KBEOuuY2DcYULNqwFR4wLSIxUPwtRa2AH0mhtRTtWNW04nY1zNQAwGpX3C7io7XjiOZX8ObBw8TNH0cz00RjR9AaM4ieb1A7hucAevlGYHtpNpBofa/vlBQhwmuvipc6hl4J+nX51VlAoNXWodYGe1JP4Q9NY2x8EXfsz3VfO9gqe7Ps1iAr1WG3lpeX+2JldqO56p0oLJfLvP766xQKBWZmZohGo93t7LQ/vX5ZEGSSdmtNAWrgFmZ0mkqldmUF0esGPzMzQ61W4ytf+QozMzPEYjFKpdJbOlFXrVbRdZ3XX389cM46n3PhwoXuY4NGn5/+9Kf5q3/1r/If/sN/4Hu/93vfsv36Tqk9gPWYVufH7rruOyqC4GHi++y5fcz/6jdw6+pF2KupHw/VZ62rF+bGfLFN5/j99LtfbG2zXsGxtei+rHK6MZKOU7q3RX25BWgQ2c/Q6RjZmAnJYiCU2ihXlS7zAjBHh5U+WTLkLtYP88kCZssGJ3PB89WotVDlHo/FfLZaGrlIcMGvNnxIBd8zarZwfDAH1hZdCHLRFBPFChTzXHWyrGseI6MtDg+XaLoaUYV+yg0xKc3FPTYaMYZjwb+zbIW3Fm8u6pwcDj6e8tVB4QBSqPdBx6dq5UjavedcYBRKtIotNL+JZ03C5DCRjI/h3Ee4ZQhhyzRp4yUPo1fvBZ7zS3eRiG5+Yf+OqNmcGBWc6H7M5gPXeeHZ6Gt38SufR47+WSUbopqWe6vZrd1ornq30/mMp59+GimlUpjeuz87WUr0GqZ2AOCjWkqEGZ0WCgUuXrwIPLobfKFQwLKs7n//x//4H7ly5Qr/4l/8C5aXl/nQhz7EsWPHvikG69y5c3iex9raGt/93d+tfM3Ro0eVj//6r/86H/vYx/j0pz/Nn/7Tf/pN78N3cu0BrMesOj/Gjs/IO22SUNf10BgFgPSTkwhdoz5bQOgaciAIuXZ/A6mBGFib63MFMAU4/QuSvVpFS1n4lX6gIVse1lQaezGoX4qOp5UAywhhz7wBTRgt2HyjQemOxK2MkDg8hZGvko+0EIVNsG30kWG89aA4OkycrhKyA8hqDT+eQKsHAUM9BKxMJsMZxJKIkVOwQUlT/R5Tg4VmhH3RYCvUrj4AckOmxhAabJqsrSeYNyOYVomjE1WGekBTJhr+3ZjdMBhWRPDsz4WboZZC7B2E08BPjqBVg4DZcsO3Z+tqUBDxm21PLrsG95dxAYco3vAkhhnHih1Eb9wPvtFQoFbAokHTGCfqBidBw+wfALRoDnoAVqfMxiyv/sFniIycfqg2ScVu9fpTvVl2a9DFfafQ5A7L3RG5DwrTNzc3u47plmX1CdN3Yrd2aymxU3sTgl5gg7q03TB3nudhGAbJZJIf+IEf4Ad+4Ac4c+YMf+Nv/A02Njb4yZ/8Sba2tvja1762I8iqVqvcuXOn+++ZmRkuXLhAPp/n+PHj/MW/+Bf54R/+YX7u536Oc+fOsb6+zhe/+EWeeuqpUOD0a7/2a/zIj/wIn/jEJ3jhhRdYWWl/D2OxGJlMJnRfHrcS8ptRyO3Vu65c1+2Cqi996UucO3eObDb79u5UT925c4d6vc5TTz0V+poLf/3fUb68TPzQEPUZhRD5YI7m/SBzo0+n8OaDjJW/L4a2EFw0/QMJtNkgmNCPZvHuFAOPRw7naN1TfG46ilcOsUzIWsjiA3AXG7MYesLCt6pYy7NoA+1S4+B+3PvBBdLXBMJXe7RfK0Y5lQ1+/tWtCKdzarF52dZIW0HQdLOZ4kRUES7tQCpk6vyN9QjPjAQ/p9DSyCvYMIDX1yI8O9oCJIuOpGo67JtoMZmuYGk+uha8bH31foaXD6r9rdYbMUYU7NbVlTinx9Uo6+JqjqfHgn9PCaBbCC/I/pUiw2QUPlkAxdgY2UbQpw3A0SJoJoipPFbaxWjNILwaXuIQem1G+R4v+zR68aLyuaY+QtQLgkM/OobWVO9DefzPMhP9CJubm9Tr9W6La3h4eEcBd2/1slubm5u7ZrcGy3Gcvu0MZhRKKfn617++o5UA0DXq7ACljjfVbvyyeqsXJBUKBcrl8o4A8GHH1mG3eo9t0Oj04sWLDA0NsW/fvu57Dx8+zG//9m/zzDPPAO3z/bAImS9/+cu8733vCzz+Iz/yI3zqU5/CcRx++qd/ml/91V9lcXGR4eFhXnzxRT7+8Y/z5JNPKrf5yiuv8Pu///uh29yrdu0xWI9xvRPd3HeyaehUV4eVUd9BWtk4TYXuKDmUpqQAWOlchqoCYEUMU5nz51XUYKm5WFQCHK/cRMtF8LcUYCZjQQ/AaqzaLKzacDCBtnKQ4ScTiEiBeHMLUa/TWFlFhWM0X0I+B4qWYMNR30ON7MAGLdYM0pZC61VroVLgp0zY8iLkdEWOYMhn5CM+RdcgawS/g7p4kCM4ZQogAssRVpbT3Gz6jI42OT5eImk+OIZ0NPy7PLthMKJgt3by3Wo01eyuAPz0GGIrmD8ZC/GvgvCIIoC6mSbTWod7HXYriTd2ENOMQNRFbwY/C4UOrFOOkVUCLK25GgqykqVXOXrmf1WGOe928m437NZuTDxN0wy4uPdOFEYiEaSUFAqFHcGNrusBbyqVX9bDbBdU7c0OAOxE5nyzbvAdfVtHT9ZsNgPgb9DJfTf5fK+88sqOk4amafLxj3+cj3/84w/dVqe+/OUv7/q1j3PtAazHuN6pLcKH7VNHh+WF6LD8hho4uCH6rMH2YLdUgAhgo4UwdaTTv5+iJYlOpGkqXOMTkzkqW8F2TiqbpjwbnDCMugbNpmTtG1XAAkYxpyAWbRFP1ohXg59h5rI4CoA1kjFA4ao+uoOmyhYGEDwvEzsI3ee2IKfQM+Ui4X/P+ZJGdij4+FBMDbJjgKzEmIxqlEoxrjgSJ2ZzcLLB4eF6KFgKC5iOW5LlWpyJRJDFGt5BbP/apQrPKwCbJW1kcghRDTKrlsJRvlO+1n8pFoCxuoFchUJ0hKimo03miCRb2yanLbTqLFL0Tww+OC5N9ScHoCbTpAgCLK2xiKjNIxPTgTDnzuTd/fv3uwLuDjAJY7dU7utvVrs1qAFbXFzk3r17gYzCh4GbML+sXtuFDojcibULA4CDIOnNuMF3GLd6vc6tW7dYW1tjdXWVp59+mmaz+a6NjXkcaw9gPWb1Ts8j3MnJvVOpJyewTh2mtrmKFCAGbs5qs4X2CjXweH22ALoAr/+J+lwBLWLgt/rPhVNo4Cf1gLM7niR2MEv9rmIRHUkqAZZmqBd4N6R12FwqDeyTwFkEZzHK1kQWs54ntt8jHq+RalbAcULvUjMyRGhEuKZK89Tfi+EdQJkTQjxOp1wcX2Aq2notT72ATSZcbF/D0oIb7TzSdpQX4EVhPsp9L8es6zA92eLYSImI/uDvlovvAPI2DSYUlhUH883QzESd8O3JRF4JsBJOBVczMRQTioYX7gvmCINkvQF3GjhAS8vjjw1hDZsYZhO9GrRr0GpzoROImioXcbv0jT/GTfQjx14Bd4fd6rTuOvYEHTCxk2v6W8VuGYZBJpPBsixefvll5YTjbrazk19Wr/N6h93ayS8rDCQNiu47gdC7MTotFAocOHAAz/P41Kc+xd/6W38LgF/+5V/mox/9KGfOnHlHeRjuVbD2ANZjXO9WBsvX4fYdQeVyjun3TpPNOET8Cs3ZdfAlsumiTSTwl/uBg7Q9/JEI2vrAAuODP2TCUhBUyIwJgwALIKa+aIe1N+2Sup1TXygqQR8+RKcyQa8vAFPglwS1ywY1MmxaWfJn4uh1l5Ztkrf6F/BMRLJS1xlXgIyWrwZ+YzswVZtuhFwkeDyJEKG7LuB+2eBIJggs8smQ1o6Ae2WdY5ngNtMhn5PXYW4ryfCmyep6nDlPYqRsjk7VOJAPnyT0QoChocFSLcn+VLCtPJUJ394bb2zw3JT6OT0/BRv3A493LB40JSByBv7to21H+KwnpkhoR9AnMljx2rbJqYPwG/iJA4jabPCz3FWk0BAy+Fmt+d+jmHz/jsAkGo322RN08vdmZmZ27Zr+zbJbvS7nu51w7ICbsBq0XeiwW53j6nVe70TXqGonN/he0X0+n9+xLen7PvF4nGw2yyc+8QkWFhY4deoUuVyOf/gP/yE3b97kr/yVv8Lf+3t/L/SY9urtrT2A9RjXOzGP8GEarHK5zPnz58k8E6dyuYXnR7n8X9tttEhmitzRFqPDkMxGKC8HmZn0eI7qerBVZ6ZiOAofJ2W/CagUyqiWn8pSQam0acxtqYGU4yOHI4iNIKtQlyFMg91/fnxbsvFGDU+CFFMsxiUVvcxIssaRrI0mYK1uKAFWmKZqNOZTamlkFExVseajsoHflwwHZSVbDaSGIzv4TUkDlR/XdMoJbQV2wJKlaRzVgGYM926Umw6sCYeDk3WODlX6RPLj+XAWYKkg2K8Y5BtPO2zWTIYSwf2LK3RonZJmTPn9aFs8ZEnaxeD2bLVwHwDPxqhVoVJts1v6MHJiGCuvo5kGGkGAJWQLP3EIoRDPJ5u3+Pr1S7Rcsau226BD+SALZJpmn3brrWK3es03d9pOR3PV2c6j+GV1jmtQkzY7O4umaX25gmFWN2Fu8B2w1duWHAyEHvQobDQaRKNRfuInfoKf+ImfwLZtlpeDYfV79c6pPYD1mFXvXdc7MY9wJ9C3vLzMlStXOHToEMf/QpaF/++XaZYeLHCtEqy8HmEFGD2bJp47Sma4hbuygqhsv85WgzfL05SCdlFVnx+zIpWGo6JgoyesoB+XD7FDORozwVDm1ESO6kYQ9Hm2qwRxRsVThrzoAjY0g+G6R4IsVLLcXPcpRxuUvQa1jB2IwNlJU7Ulo2QItheHQjRdKVOy6ZgMmcEzGSaxTesuhaZGPho8m3oI7onqbbd5FaCLK9ktwYQJa5tJMobF/eU0C75PesTh6GiJiXglFLClU+EecQUnwZDCpPbQUAPXbzNgg3Xt4hJnQsyuE0PjsBzcnikd6maauBNsPQ+K6tsRPmt4C1CKj2KIQ5iTaaKJ+ja71f5tSVORtA1oeLz3ZIpy5AkKhULAWLQDTMJE5SoWqJPj12G3VGCit3bDbsXjcRzHoV6vh7JSveCms53O/jyqX5ZKkxZmKrpbN3igL6R6sC3pum4fwKrX6336K8uyOHDggPJz9uqdUXsA6zGudyKDpdJgSSm5desW8/PzPP3004yOjuK7PlbKoHCzhBYR+K3+JXzzZpV1RyJdCYwyejLCxFHw3KrSQLQ2W0AYGtIdCGvectDiJn69HzT4lRaR8RStlWD7KLYvS/XmWuBxKxNTcWQIqb4Yi7Ka3ZE1F2skgb0eZOhWKy7DiQfbi7gaI9UELS/F8p0hygmHllbhUK7OeMJlOOaHApyNssdBBbuV8MOn1zZaaoCV3UHovlI3yEeDgvKhePjkU12LAEGANZ0K/xxnW++V0DVO6BoUDSpbUeYdn4rpcXx/nf3pfsBieiGh3EA1JP8wZkrubUY5rMhOHI6F6+GkDJ8zbBkxJcCy/BYNI0nMDe6n1Sxh+S24XccBmsY4TAxh5QXaDlNlevESySPPBQDOxsZG38TcwwxBe1mgjsapo92amZnZ9QSfipWamZlhc3OTV1999ZG0W52Jwm/WL0tlKtoxKH1UN/h9+/YFAqFnZtrs4tWrVxkeHsYwDKrVal9Mzl6982sPYD3Gpes6tiJ25e2swRah4zhcvHiRRqPBiy++2L2D0wyN0RdyLPzuOrEjFrVb/YyK1/CxpjXseQkI1q7brF0HsEif3EdmyGY0K7Dn15G2B46Pvi+Fu9APmARgTiRp3Q1O51kjSSXA0mJqMaxvqxf/1praTV6reMqQagAtHwcFwApz4hnRfTQpyFYtYIh6Oc+lqE/VqILR5MWJeoDBsXT1Ijwa86m4OikjuF/1EIZwOuniSTUrVXfVsGJIbypd4AEqVVcZPJ00fLY8i5we/F7HFc7wmhAcsHQubMSxhMV1N8OacBmfcjmQLXBoKFzojrtDe5M4qhTn8ZTDRs1kWNFaXLo1zz41sUQmk4MQD62WmVADrAHwpbsuzK/izYMtNGTuBMZYAssqojXudwXx+tbFPjZ3EOCEGYI+LO6mF0yETfANDw+Tz+d3ZLcSiQT5fB7HcXjyySfflOZqkN3q+GVtbm5y69YtbNvuY9t2Eqb3mop+s27wHWB24MABvvKVrzA+Ps7y8jJ//a//dVqtFvV6nVdffZXnnnvuHRVxtlfq2gNYj1kNtggbjXA24u2oXlatUqlw/vx5EokEL774Yt8Uz+LiIq19bWCSHkpSU7SsshNp1uaLgceFFWX+q5J5wIhNsP+ZKFZsC89oKVtydUf9eKWiBkbVTbUXUm1RHVtjr1UhYUAtyMj4ORNdAbCu3yhwSHG9H0/ooGheRoBVWzJmdd4kSDZ1kmRYNEe4dbtJKdrEtCocH2qQNCXjsfD24XxZ51Q+uF9WyHSdpcFS02JSwVRFQoCcqbXF8QfTwf0YyYSbOi4UIaewftiXDtf2dYjLnCHIYcKKydrSJPOujx3zOLO/zEi8n30aTYYL3e1w7MVCMaIEWBPJOnVbI64weBXNN+evFQa+dOlTr/gYhUVswLUmEZNDRDI+en0evBbowTiXwRDmjh/UxsZGN+6mAyZ2ioRRTfB12KTd+FN1NFhvleaq1y9LShnYn152K5vNhrJtu3GD301kTucmc9++fUxPT/Paa6/xi7/4i/zrf/2v+fmf/3neeOMNnn32Wf6X/+V/4aWXXlJuY6/e/toDWI9xvRNbhB0Ga2VlhcuXL3Pw4EGOHj3aBYa+73Pz5k2WlpZ47gef4jc/9XVqy+qFzq2GxLf4Edhu1rkNuPdHTSBG/swo0ajN6AGJXt2itQ2ILE9TwgZRcpTaIn9F3Yb0Sy2MXAx3KwhqvYyBrgBYZszCVzAhoulCLLiwZqRHQwpiCvyx5cCYolvRKNlYcY2RahyIs1yQVOIuLb2ETYt98SAoCmOdDiim/jq1WhFMKrpJ4ztE82y1dA4qWoFZEQ5uwqwf0obHZlNnKBr8a6omIC1NcMTSOb8Sx/NMLjh5/JxGMlnhcK7IVMam1NTJKLZnKf5mnTLjUUABejS4vxXl1FiwjehuLqNpGvpgBhSQiegoe888BHwZ8W7b0bAduL+ybXJqsJr6KqkTL+w4dQdBP6hqtcrGxkY3EiaRSHSByU7sjYrd2tzc5M6dO0r3dZXIXaW5erPslsova3Nzk9u3bz+SG7xlWYyPjzM+Pq6MzOmwcYPsn+u63RggaAO3bDbLwYMH+fVf/3U8z+O1114LhC/v1Tur9gDWY1zvRB+szgXl8uXLPPnkk4yPj3efs22bCxcuYNs2L730EvF4nMzha5TuVYkOWzQ3+oHA1s0yRkzHHWCACrdKaJaGP9DOKt2pUXQlSxclkCA+FmPoiM2QBVq0iT+QKSi3WpjZGM5gkLQjiR3I05gNCtpjkxkqCoCFob5Ax4SlcKmCqZjAkxJ94MKuCcFKU3JIAb6smAEKqDhsttuondIRZOsmMMxczWDLbFExa+QSVY7lWhhaePswqXtsNDSGFUahYTBqJOJSdQRJM7hNP0QqlLYkaw2d0VjweDLxcFCxUlcDrP07AMP2PgjGTdHGRdUUc4tJFnwPkj5n92+RtvoZ1AO5cIDVrLYgp37OFhFQDBaYuuT2epRjI8HvjiiH2y6Ybvh+hI0eCASVOxe4uiUxTbPLEO3EAEE/u9VxO++wQL3sTQeYhGmTBoXgg+7rlmVhWVZXr7mT5uqtYrcG96fDSn2zbvCd7Vy5cgXf97vsViQSCexPr4u7ruu88MILoX+LvXpn1B7AesxqsEX4TmKwHMfh8uXLADz77LPd0W9ot+PeeOMN0uk0zzzzTPcitv97x7n8r+/AkAcDEXDSA2tKw73Tf4x+S5I+HqN8q38h85o+uSdSbN1ot/7qqxr11SjzwMR7nsCIFYlESsQrLfztKcHoZCYIsAAzF6MRnJBHhBiO0lIv8PXFotI01QTWhcaIYpEUcQtksAWl2y5Eg+Ajawq2HEnODD63WXEYT+gkWmmoprmz7lOKt5BWg6rrkVTosFYaBsOxIOs1mg5v6y3WDE5kFW2zfPiCvlYPAVgK/VWnGiHMW0ILB4bpSPAcx3XBcd3g9fkI9ZbJfU2nrDXZP15nf6ZMMuKzUIywLxtsXY+ndzD63ME3suw8YF57S/guRZkjK4It6LhTwhcamgJ8RZxweUCm2R7ScByHpaWlrh1AOp1mbGxsV7mCpmkG2JuNjQ0WFxe72qRediuMBVKxSffu3aNSqfAHf/AHu2KT3ip2q3d/Btm2h9kuqM5PWNh1qVRCCMHt27e7flm1Wm3Pxf1dVnsA6zGudxKDVa1WOX/+fPei3Xvx7rQLDx06xJEjR/p8YuSR9h16IpKgSVCnokd1VF5KjqFehJuaetGpNhtULgNkEJpk+pkoQ5MeTQXbAGDX1cyBvaV+vbbZUrrSy4ZL2TBIK/5O6zWfkUTw4m3XHKUAfNwi1I6giEZOAdYGMZfla4xUY0CM+1t57JhDU68wna0znWqf52YIiMmHnFuAqqMGXzu50OsxC1Wcz2jMp2ILUlbweFLxcJC3GgIM96XCfyOa1mb/Rn2fUd+CBYvr9zOs4mKkYSi5Tmwga3EqY1Np6qQUTFo0rNf3kLo57/HCfsX+IfHT41AK+iXF3XKos3ym0T8F20kJKJVKlEptX65IJMLIyAjDw8MPDTvuZW862qQOK3Xx4sXu5F0H4DyM3dra2iKdTjM9PR2qldppEvBbxW6pJiV34wM2qG3r2GO4rstnPvMZfuEXfoFYLMaBAwdoNpuhk5t79c6qPYD1GJYQAinlO4bBWltb49KlS0xPT3P8+HF+93d/tw2epOT27dvMzc117Rk61Ww2OX/+PPpRiR7VKN2poRkC3+1fVGUxZPLHjdJQ6GAMx0Q1/u9WHjAA0hfMvdZiDjAnIiSjB5k+pWN5ZZqzG+BLGvPq4OfmXBFpCsRAALNwQQ5bsBFc4BdLDmkFkAojO8ZDbr4jmmDVhTHFr75m+0E0BeR3uEKs1CWHpQnkcSp5rlge1UgdK+Xj+q2AD1TChOWazkQi+J1LJtTeWju9xxxEoz211rJIWYrtKQBZp8LYrZjms1rXGVMYtU4oxPYdofxr9yNs1EyWkTiRFkcna4wl2g3fuWKU0+PB5u+BfBPHE5iKFmxuh6GDRDLcCmC1rDMR8pwdyWI0gqHQUbeK5dawjXBbgFarxcLCAouLiwBks1lGR0cZHh4OFW93yrIs5eTd/Px8gN1SuaZ3NFiD7NbgJOBufK7C2K1CofCm3OB7tWSdDMdH8QHrVCQS4eTJkzzxxBN8//d/P3/tr/01FhYWOHfuHEeOHOHDH/4wP/iDP9jH9O/VO6v2ANZjXG+3yF1Kyd27d5mZmeHMmTNMTLSXAU3TaLVa3Lx5k1qt1mfPAFAsFjl//jxDQ0Ocfv40pT/xx9z/7WWGzmTYvNLvel1daJCcilFd7GcGirerWGkTe8BrqjrTQI9oeAMtu+a8o9RzOcuSWkZw6b+0gAiRzCT54zbjIxpavUFLkUvo5y301eDin5kapryxFHg8lYmAGwQG2ZBfbxooupKsQte12ZKMKR5PKMAVwLAlqHmQUNzANwa6TnFbJ26nKJXh7kqaUqyJMCscG2qQ3XaEb5gxVALvyA5ZfBvNEFAmw/VFdV/NOEwmPJquIKqwXYhHwhmYtYYaYA0ZzVD7iWxSxxSwHwF2FHk/yiUnx6buEskIXL+BMZC1aOlwdyPKkeEgkzWeqIUykLoTzvRtrjeYUIRwA8Syw6AAWACZxjrrqYf7LnXYra2tLba2trh58ybRaLTLEO0kbofg5F2vr9T8/DxCiL6sQ9M08X0/kA04OAnY0UptbGxw586dLivVabntht06fvz4N8VuDfqA7Tbr0PO87jkTQjAxMcHBgwf5nu/5Hj7+8Y9z/fp1fvM3f/MdNwW+V/21B7Ae43o7ndxd1+XSpUtUKhVefPFFUqkHeSRCCC5fvkwymeSll17qu/B0vGWOHTvGgQMHEEJw6E9Pcf+3l7FDJrei42YAYCEheyzJ2uv9uhXpQu5Umo1Lxf7HPcgdT7F+sf9xgOyRJGtvtLfTKgmWvxFhGZh8aYxIvk5mqIm9vILWcYUPWcg9Rw129VoLIsFVdcwSNKVSVsW6rQZgyaTRPpiBGt3hSrDmwiHFGhKiyycjoOrAsN9uJW4WJTNxFz1jU6xVObwv+J6phIvrCwxFILQwTVStwPG4R90RxBXi+GjIOdYEFPwok4pWXEoP91YIm0w0BcxXDaYVrvJpEQSNo6bGKBaXZiMsVEzmHI9YzubYeJlspP36zbrBEcVnxS3JfDHCtELXtVPWormDMezmepUQ7EXeL6GGXg+vZrPJ/Px813gzl8sxOjr6UONNCPpKlcvlbkRNxzXd8zzS6XTbnPUhrNRu2K1HcYMfDHLO5XLdNuBbkXWocnEHuhosIQSnTp3i1KlTu/hL7NXbWXsA6zGsTotQ13WklKG5Xt+qqtVqnD9/nkgkwksvvdR3wV1bW8O2bcbHx3n66aeV9gzPPPNMV/MAMPrdGdCguaxeICsFtRt3pab2sbIVrSoAqTCqBEBlQgl4Hsx8vbPwjZE64JHd1ySKo/TVslfV+zMREdQ8SWKAJtEEbKEzoZgMbIV0z7SGWuie0GDTkQwpmCwtaipF8yMxjbBJtFUbktsyOoEgUzehblIhw9XbLcpWnWS8xol8A0tve17NVg0OJBV/Qycc+CzWDI4pxPGG3VRmLAKslHwmR4KPTyZcHCmUrceYFd7K2WzqSoA1GvNoeBoxPfi9ycXbu3fc1KEao3knyjccScNysDIavqwomarViqUEWHHTZ7kSZSIVBFoH8nU8v20DMVi1zU2GM+rj2hdxmXr/+/F9n3v37jE/P99lq3ZbUkqklF29lZSSWCzG6OgoIyMjO4YmwwN7gmw2y5EjR7qZgDMzMywvL7OxsdHHboVpnFTs1ubmZoDd2o0bvEq79ajbUWUddrRbs7Pt6RjTNFldXe2ydoNROXv1zq89gPUYV+fH77ruQ+8q36paX1/n4sWL7Nu3j+PHj3eBnZSSe/fuce/ePaLRKBMTE90Lr8qeoW97Ny+SfTpB8XyNzJEkpbv9gMpZlOhRHa/ZD0TcVfVi0VxV63RKy2qgVphTh/Fu3ettDwoqswaV2SRYEEmnOfxMnLhZw55ru8k7m3WKrpp5WrbhqGJoq1BzmVDos9KWGvxMRMD2JZZi9W5YanarVbNBYX2QFxIbgaX4nMH2YafirkMMnZiTglqK+xuSetbBliWE5ioB1riiPdj9HNSB0JOJcOf4VNpCpffSBcyVdQ4pjE2zZjjT64Y7PDBf0TmeDb5g2GgNtPsE06YAGWFuLc7tDYNlXHIjDsdGisS3P9/2wm+ElkumEmBFDZjdiiqtI6ZS9VCn+ub8bRrFOul0lKNHj3L06FGgHbh+5coVms2dLCCC1QFnjUaD2dlZZmdn0XWdXC7H2NhYF0jsVJ1MwI2NDbLZLKlUqisof5Ssw91OFO40LflWslvRaLSP3bp+/TrVapX79+/zsz/7s9y/f5+7d+/ykY985BHO+F693bUHsB7j6gCsb4cOS0rJzMwMd+/e5fTp00xOTnafc12Xy5cvUy6XeeGFF7h27VrXyTjMnkFKyf3797lz5w6nT59m9M/X+MPzF0mMRgMAy7clo89mWHu935fK2fLIHE5Sutf/envVIz4apb7Wv4A4Sz6RrEmr2L+guysSK2Nil/oftzdc9LzAKwwsXjbE81mu/7cKYKBHJ2gmawitTDoFWZWtqaX2sFJ0DgEYCWHVdCFYaEkOKNidUtVlnwKsDe1wlVhq+BxUeG7FQwBexhB9+jBDCtJbFjDCnG5wodGkrlcYz9Q5nGkD3eGoFzoV6IWgm4ge3rqTjWbb2l5RxZaOashhIu7S8oTSdV7VouxUJWQ6MmbAWstkNBIEhwm/QcYSZDBhy2SzEOOi4+MnXVJ5DVAD+rDpTYCyE0UV3WNoMLOp9teKeSVefM8vcezJaV55/zQf+N6DHD2WI5lM8vLLLwPta8etW7dYWVl5ZHar8/6NjQ02NzeRUpJIJLpC+U47TFW+73fBWS6X4+jRo30ap28m67BWqymDrvP5/LeN3bIsi1wux/Hjxzl16hRf/OIX+Zt/82/ycz/3c/zar/0aH/rQh/jwhz/Ms88+uyMDuFdvb+0BrMewOj9IIcS3xarBdV2uXLlCsVjk+eefJ5N50JOo1+u88cYbWJbVbRd2xPc72TNcuXKFra2t7vaSf7rOtc8v0QyxRxAhN/6J8WgAYAGkDyUCAAsgezTF6mtBA9Hs0VQAwAEYQwqABUTyPYLWJpjNBJDg+lqT1YiLkawxlXS6zuearXZuHw8BCjEByy3JhAqBxdQ+WWEOBkOWoI4grgBMtRD2JrcDEbHhqFk6v+qQjhmkyUE1x7V1STVaJ2JVsEyPk5bKWyt8cSnaOtNKsBTeckykI6jYLU2025GH06pWafgNyk5L32pVMKr4+w1FJaWWRmZ7MMAUgkOWDrbO6ozO5flpNnWX8fEWR4aKmNtCeZVwv1OVWvhzhbpJmBX88XyZP/zDJf7oD5f4f/zTVzlwIM2f+/PHeOrsCO/9rmmiUYOTJ09y8uRJADY2Nrhx48YjZ5x2wFmtVmNmZoaZmRkMwyCfzzM6Ohpo/6lkDSqNU68/1W79spLJZCDo+tvNbnme12XzUqkUH/3oR/mZn/kZfv7nf54zZ87w27/92/zCL/wCv/zLv7wHsN7BtQewHvP6Vls19AKol19+ua8VubGxwcWLF5mcnOTEiRN9UzPLy8uUSiWlPcMbb7yBpmm89NJL3XHw9FSc+bLN/NerHHgmxVg2iii1KN1st+nWrxbaScgDgKC4pNY9OU31IixDNEd6yBRe2ArrKGJxABJSJ9WKQitJYRMWjSZuospQ1sGVXkBYntQFa65apF502y3BwfJdD5UITBWj06mlhs9RBcALswHNIWl4kpiiR+cb6rzE0YHPj9qCqN0GnneBcrGJNCscGWp0QU1ea4ZO1kXiarCUsmC9oSuBkVdvhLJbpZYagY5EPWqOIKFgspKKCJ5OhQnnATYck0wkuO9jMY+GqzGimbBmsriSYN7ziOVchvLhwDG6w35EQsLJAc5MVPnDmQe287l8lF/4f12g1fKIxw1eeu8k7//Afj7wvQeY2pdmeHiY7/qu7wLaJqXXr19nY2MjbPM7luu6rK2tsb6+jpSSZDLZ1W71TtmpqlfjdOzYsYD7+pv1y6rVamxubgbYrQ4rFbZPj8pueZ4X8Lqq1WokEgmmpqb42Mc+xsc+9rE3dV736ttXewDrMa9vpVVDGIDqbe+dOnWKqamp7ntc16VSqeD7fsCeYWtri/PnzzM6OsqpU6e62/N9nxs3bpB/wWX+6xpGPMbXf28TgNRQhJF9PmldJ2FFAjYO9fstZcxO4WYZoQclSZt3ispj3boXAtTW1Avb+vUySIk2cPc5LExsTWL57cdjbhRKUewS/D4NookmqVSTI0mva51QcNQAK4yzSHmeUpwU18VAIPSDaoasz2OJHYTuDhxUrFthbghxXbBhS4YVn9+qSYZkeyqxVJIsJXwqosxYukbc8phS6LScerjQfcs1GVG0XMd28ppKqbVbAEt1g2OZIMDZlw7/bYXFDQEUG0CInnmpZnBk+7OimuCYZkDVwK9YfK2VxI7Z7J9sciBT6gLP6aEdzFJ3iNN5YvSB/cNTZ/NcubyBu92Wrdddvvg7c3zxd+b4B/wh554d5bu/Z4rv+u59vOf5CQxD56mnnuq+f2VlhVu3bj0yY95ht6rVKtVqlXv37gHtwPdOm3CnCB8Id19/1InCDrt14MABXNftgrZr167heV6fX9ajsFud/emwW51M1nq93t2fPSf3d1/tAazHsAbjct7qFmEvgDp58iT79j2Yy/c8j6tXr7K5ucl73vMestls97larcYbb7wBtFPkey8m8/Pz3Lhxg+PHj7N//36lAP7P/N9e5sr/+WU2Zx4YOFY2XSqbAD5H35smcmaIlOVTuV3Eq7Qv3LkjKZY3NvuPoQnDT2bZuFzse9wrStIHE5Tv95tENtdsjGGBuzEQ8FyE5L4Y1YX+FozmQkH3yPvBn+CaZ7NPBGmUhi8Yq+WgBnekTz1eJZpukkiD0tE8rmaKhi1BxZWkFD4LLUtttJpJqDVgOzFVtRBskQgBeAB21AKFs3i6b/0UJGo6ie1W4h1LMGtWiEWrnBhuEN9ulY3sAJYcoV6Q81FJsaV1fbt6y2uEA7aKrUaNcc0PjeAZiT+6Zgmg5qnTCTShgW1wIipgMcKduTTLvsfotM90eoOGqxNTRBtNZcPbeef2t3jP82NI6fDG6wX8EKCdzUWolG0++b+f55P/+3kymQjf88o+3vf+ad73/v0MjyS6sTnQNim9evUqxWLxzZwCoO2HVyqVkFL2Rfg8LKC613+q40/VmeB71InC3qDrWq3GxsYGq6ur3Lp1i3g83m0BPozdGpxwvHTpErVajVdffZX/9J/+EyMjI1QqlT2A9S6rPYD1mNdbzWB19FGFQiEAoBqNBufPn0fTNF5++eU+t+fOdOH09HQf4OuwU8vLywF7BpUA/sxHxrn4G0vkj0Qo3O1nGxavlGjVvLbbuxAcfjLN2IiJDPkVmAn1E4nJWABgAehDQYAFtI1OF4Ial7rwUXkwu1IqW4uZVIRO8rMuNFKNNDTSrKzYbFkeMlFlNGlzMO6jCcGw8GkJQUQhPl6xIaU4vErNAYXQPeV6oVeLdU+wX7EGpUM8t4YtQd2TxBUgq9JwlS26MasN71RLXXHL53QiCbUkCwVJOW7j6GUO5euh4nin6YYyRGURJauIQBrdAbAlk+Hs1nozJJsx6uBKgaGwhUjv0NJzvHBgVrIfiPTTuiCtG7ACpeUJLlQF2XyLgxN1plIPGNehuEOxYZBVHN90qoxlaPzRVwtMTSWZmk5SLjW4c7tE52eay1kkkyZ3bhcf7EepxRc+d5cvfO4umib4gT93lAMH07z/ew/w5JMjmKbJM888A7RvyBYWFrh3794jX4s67Fa5XKZcLnP79m0sy2J4eHjXAdVhbvC9WqndaK467NbBgwdxHKe7nUF2a2hoKDTqpsNumabJ9PR0dxry85//PI7j8N/9d/8df+pP/Sk+/OEP88orrzw0D3Kv3t7aA1iPeb2VIvcOgNJ1PQCgCoUCFy5cCLT3VNOFN27cwPO8LjvlOE7AnmF1dZVLly5x8OBBjh492mW0nv/hfVz8jSU0hb6mUXLJHNMo3ZYgBfcuVbkHCB2GDpiMDOmkfYvSrTJIKM2o236tLfUdvwwhAgbd3zsV04SKFCKpqRcEq+q3d3ag8sKibnsknBHqRTiv2bQSVabGfZxmk6OKG3oZooNKh6xFWQNqQiOhCA12NB3VgRhNN3TMcdWGQ4q1QfN8VOjS1ASLLcmEon3Y+xGaFGRrEWCEallyKyrRjTLDqRrHcq1uyywfCV/IKy0BCj3aUFRS9XSSevC9stWEkLWu5qjPgS5grqKzX5F1uFNrUeWr1Sk/RPSnC4HWjHDEAeYiXHUylGOQyzc4nC+y3oyTjQVTB2Kmz+KNe0CMxcUqi4vtgZB43ODMk3kiEcHmZp07t9W/FYAXXpzgP/6H2wD8q599nbGxOH/ilX287wP7+Z5Xpkmno0xPTzM9PQ20dZtXr16lUgnf5k5l23ZfQHUmk+manD4MkIT5ZXVc3HeruTJNs4/d6g1y7rBbne1kMpnAdjzPQ9d1DMPg+eef5/jx43zyk5/kS1/6Eq+99hpf+MIX+PznP88v/uIvvqlztFffnhLyzczW7tW7unzfx9k2b7xw4QKZTIZDhw59U9vc3NzkwoULjI+Pc/LkyT4ANT8/z82bNzlx4gT79z9IpO2dBjx37lx3uvD27dtUKhUqlQrpdJonn3yyz56h45f15JNPdlsO0G4xvv7a6/zWjxaxS20QZdf7F6p9z6RYeCN44R4/G2PlQptlSg2ZHD4ZR1YrUPexl4KLnZYU+NWBn45FG7MMrJfSBOlItIHFz5Y+GgJjMGcNiS0lUcXoY0E65EVQlLwV88k1gq+/Lxvk4zbRZIODKZfO8OISOpMKUORKiS9R+mTdqkuOK/ywbtQlTyge96XEEwKVhHoGg0OKVuSWI8mFDAzc83QOakFwUfQgGwIMr9Ukp7YZOdvwKUcamJEKR/INEqbEVKyP59cjnBtRs1G3ShbHM0EkXWwJshH1pfRmPcGJeJDxBLi4YfH0cIjvmmeSUbjLFx0j1JfrejHCSYURKcBraxGeGw0+1/Il5yswMd7i6ESFoVg/2/qjnz7Fb90I+r0fOJCm0XBZW6tz+EiWkZEomxs17t6t0FlVzp7LceH8VuC9ndq3L8kTp4Z44cXxrg2EEKJPX3n//n3m5ua61i3fTHUCqkdGRpTAZqfqnSjc3NzEdd1daa4Gy3GcrnarUCjgeV5XkN9ht7761a9y8uRJcrn2gMHi4iInT55UOrzv1Tu39hisx7y+2RahlJLZ2Vlu377NE0880b0LhfbF8dq1a6ytrfHcc891LxbQz3b1TgNC+w52fX2dI0eO9Nkz9No9vPDCC6TT6e57NjY2uHDhAvv27eP9Pz7O5//BVQ6/d4h7f9SvrVq5ViOSNGhV+xcozXswql7ZdLj4h20x/IEXk0izyb7RFLW7ZVqF9mJoTgpat4L+VrnTKbau9gM44cCGcBmR/VDDEhrL0mZigC7REDSTEFWtySlDFeVHqWaT04JtB0vqpBsZaGRYWpfcsuqkJ1wsr4IXl+gD4M4QgiVPMKmIrLFD1rfREEd3TQjmm5IDCuf4VkgrMmeG68PqDbdtOT9QWR2l0z30c2GWqzHsJqCWYK0gWYk7GHqZwyNNxntaeGkr/PfgGxYqvVs2Iim7OmmFxslwwnMWHT98knCpLMjkgo9nTZeqI0gqphbzVjgbHQuxcYhoAsuOcKAhcO5FOO9I/Jwgm6pwMFfi+aMuv3Wj/z1Hj2UpbDYpFNoC+Xt3i9y7234uk41w9GiWRFLj/OvhYTvT0ylsx+d3/9ssv/vfZrs2EO/7QNt3q2MDcfjwYQ4fPgy0W4FXr1590xl8qoDqjnbrYQHVYROFvZqrnVipTpmmydjYGGNjY6Hslm3b1Ov17nZqtRrxeHwPXL3Lag9gPeb1zbQIewXrgwCq2Wxy4cIFfN/npZde6ru767QLx8bGAmzXnTt3WF1dJZ1Od52joQ3I3njjDQzD6LN76AV4nYnEfcMtfvOnb1BaDupo3KbP/pez3Ptqv2fV0uUy6bEI5YEQ5sKsTWXZZe7qFgjJyAGdfA5k2GKVUnsdyKimtBpqSl+ptypWWmQVgKlabpFXPB4PEW2P6ia+7LBngqSdwJ+FJhm+pNWJJxvkky0OJ3ys7fWgqWmoWn7xkGt7XshQgFMNwSpjCXWLEqCk6aQUz4V9PkBFN0go9nkkRAemIShvmDwRH6ZagUsRj4pZJZesMa1wQ+9Uve5ASP7xUkUjnQt+1kQi/PeVVqVodz5rB+PQElGSii/UWNyj4QolmBqNhzNA8W4MlGDCFG0QX00zs5DCXZfsP5BmaipJpWIjpWRutkKlombeyqUWhqHxB19eRtcFJ08NkUqZrKxUmJtt3zWMj0eoVltsDbTbZ2fLfOrfXOVT/+Yq3/XdU0SiOu/bNjndN53u5pN+6Utf4vnnn2dhYYGlpaU3FeED7cnkYrGIlJJoNNq1gUin0zv6Sw1OFPZqrq5evdplpTqAKwy8CSFIpVKkUqmudqtQKHDt2jXu3r3L7du3+cIXvsD09PSe3updWHsA6zEvwzC67cJHqQ4DJYTgpZde6hNtFotFzp8/z9DQEKdPn+6765qbm1O2Czvhz9VqlUOHDvVNF4UBMt/3uXr1KhsbG32C+uRwhGd+aJxXf3mRoeMRNm/1g6a1WbUTdnKfEQBYlWWb9AGd8qwHUrB+H9bvgzAFmTGd4WGItiTeoo/0UZqWAmh1tX4qFaK3SoUBJiOixCXDwsDGx6L/rtmQgjXpMKpoKzZdjfHyEG4ZruHiDzUxIzUkDqQCL2cyKpCorb1WbDiiuP6nk2pT04z02kHVilZk1faV03qDPlm9Vai5jKvE+Z6LLwjYYQDE4g8mJuMtnXgrA9UM82s+69EmiWiFk6MtEvoDgLSTr5UWjaKa7osbsFbXGY0HwVdChrNbO9lHrhV9phR5igArdXXcz0jUDQdfIQL+pC54Ku0z92qZudkyTz41wupKjeMn8ui64O7dIpsbD4CergvOPTvGq3/c1j95nuT6tQcs8thYnFOnhyiVG1y9EjTm7dRLL0/xh19ps0xf/J05/uHf/yNOnMjxvg/s530fmMbz2kajJ06c4MSJE0D7unP16lVarfBzqqoO2Go2m8zNzTE/P98NqO5E+DwsSixMc7W8vMzNmzdJJBJdsJVOpx+q3bp69Srvec97aDabXLt2jc985jOUSiX+/J//83zkIx/hQx/6EBMTE490nHv17a89gPUYVu+dma7rj0y3hwnWARYWFrh+/TrHjh3jwIEDfWHNnXbhs88+Sz7/YH6uY0YaiUR48cUX2djYoFBoX3zDAFmr1eL8+fNdhqwD8KSUzM3NkfquLbRfFcTiUQanu6qLHhOnUywPtPK25oKMF4CRCC5I0gESgjsX2pAjmYtw+MkE1c0aRVyGBn5aw8KkLF3Sov/xIQxsXWINmE4OCZOq9EgOAK2oL9iUDkMDgElDsCEdJkVwIXDVzgtt8LN9yAYGbCaBJGXp8LVoCz1RZyplM7UNdqKiPTE4ovBvCtHxY7ZsUAjTNSFYDYnsiRgCVcsxqQs2XcgpsGcY2RDRBCWhkVGI872mqwRylq/R3IozFYmzWJBU4g4tvcK+bH1HF/hK1Q4Vuq831QBrPOHh+AJT0ZLNhGi6AHYYJMSzoij7yMByXe1Gn49K6r5OXAvu44GUi4bk6WfGuXZ1g1bLY329fc0QAo6fyDM0HGNzo0YiYfHa11dC9y2Xj/LaN1apVGwiEZ2nnh7BigjmZsusrbaZw1OnU3ztq4uB9968ucXNm1t8/nO3kdLl2edavP8DB7o2ENlslve+971A+4bt5s2brK6uhp+okFIFVMfj8W578GEB1WGs1ObmJpcvX0ZK2WW38vl8gN3qaM0MwyCXy/E//8//M4cPH+bjH/84f/fv/l3+63/9r/y5P/fn+Mt/+S/zP/1P/9MjH99efftqD2A95vUoTu6DgvXp6ek+AHXz5k2WlpY4d+4cw8MPRLGDYKiX6laZkXballevXmVlZSUAyEqlEufPnyeXy3HmzJkuQ9YL4r77Q8/j/sQCX/2/Zhh7IsXqjX4wZSksGBrrkqmnMyxe7Ge4Kgs+QoPBNdo0InTy3apbLpf+qP2+YkRQigsimkO2JUhsmwsUFABLIFh2mhxQtP3spNa1ZejbH+kFABZAJESfpVi7AdBrvjJDKCNMKk2NeCvJVgFWrRZavkFcr+EKnxEFU5RPm+AHUdyoSbije0TdJkz46klCgJouyCnAV2oHrfJKzSOjEOHn9DA+DjSrPRmpIcjULWAIuzLEfctjU6+yf9xmOlrpE8nvZK1gxqOotFu6gIWqzgHFJOFINBzMhempAIplJ9Svqxzi1wWwWNY4lg1eC6K65E+9nOd3v77eNRntlJRw62aB6JzOsWN55ucqPP/CBK7rc/PGJrWexILTZ4a5P1OiVmsfV6vlceniA43WgYNpjhzNsLhQRtdBdVmank5QKjUplz3+8+dn+M+fn0HTBE89PcL73j/N+793P089PYqmaZw+fZrTp08DsLa2xs2bNx+Zre+wW/V6vS+gujfC52EB1YOaq0qlwubmJouLi9y4cYNkMtnHbnWux73Mf61WI5VK8dxzz/Hcc8/xj//xP35T2Y979e2tPYD1mNduRe47MVC9Zp+DdgphYKhXO6UyI63V2shicHvLy8tcuXKFI0eOcOjQoT7D0fPnz+N5XhfEvf9vRPmN/99trFSL5CmBXDeorbcvsLNf3yK7P0pxrl9vYyhsxp0yZI6Jtr1DT23ebBJNGzTL/YtjxNWwtzRsIlSQEPNJpUB3dFUHKTBd2P1c20P1EzVCXu9VPCVgSrma2ldLGDQNSVSh9WnFoCNFsuwIrESwyTJHja2ETSrV5HDCI7m9ewnbVV5NNCHY8AXTCtarWfeUQvdRS4SCsnLNUwrdx6Mi1CfLDVmHcqagiSCqAGx2wwUFKIvZOqY+hD/jclcbphRrIMwKx4YajO/AbtWq4SalxZbGAUVLNm1JCk2NfFRhFrtD/qEqkLr7XCzcryssmBpgOtrk0OEMt28FJwKTSZP9B9JcvtQGSxvbLUPL0njyqRGSSRMp4fz5VVpN9X7rumBkJM7v/e58e5spi+PHc4DPvXtFilsOExMmW1tNqgPCPt+XXDi/xoXza3z1q0vM3CvxyoANRKd9B+0pvs708pspz/NYX19nY2PjkQKqoc1updNp0uk0hw4dwrbtLrt16dIlpJTdaWrHcbrsVr1eJ5FIBLa1V+/s2gNYj2E9qpN7s9nk/PnzSCkDDFS5XOaNN94gk8l0zT47tbS0xNWrVzl69CgHDx7sC2sOc3OvVCrcuNEeWXrhhRf67Bnu3LnD7OxsIJ+wYziayWQ4c+ZM9z3pkQgv/6Ucv/XJFQ49nWZms8yhJzJMjCSoztcQ0SCjMPf6FokRg9p6/zlR6KTxXTBGdBgAWDHPoIxDGhMQ0NCpNMBH42ZSEo1Kkr5PriXQhGBEmHgyONGXsgU+wTidMd3qEa4/qGEMmtIP2DskhE4tIkm0ghfkNdtmvxYU4FbrDsMKfVhCWmRqCajBPenjD9m4WonppIMnJXmFxUITdctvp0DoimkSUzBiim4j0L6QrTgwrthm2HsAVpo+BxVTjpkdrowbZYexhMDwBUO1OBBnoyipxFyakRr7c3X2xfuBe2YHdiuWVLNb0M5MVAGssZiH7QssBT2pcqHvlNNohYr0d+JDmgsrS1rQ5wABAABJREFU3L6VYXg4xuEj2S5DZZo6I6Nxrl3dDLzHtn0uX1rnmWfHuHJ5nbGxBPumU1QrDjdubOA47U+0LI3TZ0Z47RsPWovVis0br7fbe0LAc88N02g1iEShWlVbXrz08iRf++oSAP/+393i3/+7W5imxnueH+eV90/z/u89wPHjeXRd59y5c+1jlpLl5WXu3LnzpiN8BgOqh4aGGB0dJZfL9V0PVWVZVtfhXkpJuVzu+nf90R/9UddouVgs7rm4vwtrD2A9piWEQEr5UAZra2uLCxcuKAXrHTapM0bd2y68desWCwsLnD17lpGRB2rcDlgDAuL4lZUVLl++zOTkJCsrK92LU68AfjCfsGM4eujQoT5Lh05b8syHI9z6/SyVgo1uaczcLjFzu93KGx6LcvJPDmGvOqxcKSP9NpCyRjxqA9Pl5XuS6JCgudm/DC3erZBRuFI2hUtaBnVSa7UWI9UoDXRWhUc0CwkDZMNlfMAxKi50VqXN2MD2TSkoRX0yzX5goAlBAYdJxf6sN1okFG3IsKV4OBZREh15YWALiSUFmtDQClEMoqxvwLxRJpds9bnJA2gh/kWjJtgILMXSvl5xGFWwW8M7aI2LjmRcAfBGFSHVnaqHfPVHrXBGTMXzCATphkmllqdZzHLZ9ChbdVLxKieGGozvMEnYrIWzW1V3h5ZeVS1mn4i7eFKdRpRTgLVOZeLhn3Uw1WbnNjYaXYZqfDzOgUNZBNCYdliYD/an3/P8BG+8voLnSebnK8zPt1v1iYTJmSfzWJaOEPDHX1sK/ezDR1JcvVqg0Wjve34oypEjOVq2zZ3bReo1jydOxrvgqrccx+erf7TEzEyJf/NLV7AsjVfeN837P7Cfl947RTxuMTk5yeTkJNC+Pl25coVyOWi6uptyXZfV1VXW1taQUpJKpbrsVjwefyi71WGvNjY2eP7557l58yaf//zn+cIXvgDAP/2n/5SPfOQjPPPMM4/k4bVXb0/tAazHvHayaejk/w0K1qWU3Lp1i/n5+QCb5DgOFy5coNls8tJLL/XR2mHThR126v79+zz11FMkEgmWltoXy0EBfK89Q5jhaIdVy+VynHnPGQ7/ap2/+fJvceI9ea59daP7uo3VJkuTDe5eLZDMmExMGZi2pDInMVPgDPiRTp7Mc+8P++/UM1jUDZe42/9TyptRpC0RAyyTLh/8W5M69hbY6LQyGhUJyagk1ZAkZfvi2QixcSjUbTIKwKRHNCUwCmsrjkQtJXkSa9KeShxgwwSCou4y6gYvHZ5tkSymqRfhsulSj1VIJRrkQhgVTQgWGz6HFAAozLwgZwjqCGIKUBYm/M4IqPugwg9hy50GLLUkkwon+tQOdhHFhsdUQhBzdGJOCmopZjZ8SvEW8ZzDhLUVaO+FnR+A9A4B0+WeWJzeMjRYdyKMmMH3je8AvhIhLBrAoQFh/Nh4AtPUeLUHGE1Pp9g3naJScbhxfYNnnxvnG19fwfeDf5hazeHGjU0OH85y7eoGR4/lGBmNs7nR4NbNB9OFR4+nmJ+t0Wo9OEeFzSaFzTbLY5qCV94/Tb3mMLUPFheCgyr79iVxHJ/V1fZzv/qpa/zqp64Rixm8/F2TvPK+ab73Tx5kal8Ky7J47rnngAeZqnNzc286wqdjmHz37l1M0+xG+OwUUN1xcbcsiyeffJJPfvKTDA0Nsbq6yvT0NP/iX/wLLl68yL/7d/+Os2fPPtJ+7dW3t/YA1mNeKpG77/tcv36dlZWVQP6f4zhcvHiRRqMRYJMqlQrnz5/vetX00uOLi4tcu3YtANZc1+Xy5cuUy2VefPFFUqkU9Xodz/OUAnhoX4AuX76sNBztsGC9rNrk0RR//f99jp//2DcYP2axcvvBQnL3fIGDT2W4f6nE7XJ7EdF0OHLGItnUaC20NVgAc68X2m7tA+tQ3XOJD/yUDFtQFDZZ2U+5ZLGw8bAGIIRfAheNUllQQiKjPqk0mCG6rTAbh1hILMuQMJEEAV/CFtSkR2Jge7po2zsMmqBC24FeVfkesKY7BiknB+UcG3jciVVIJpscTLoM9WzSt9Qh0mE+WULAct3nsAKU7UDAsGpLDilagaMpA3z14ln2YFLx+NgOdhWqXTCkxlAtxlwpTsxIMR91qRlVJjI1jmRtxuMurt8GRoO1U8C0s4Ox+UpZMjIUfNzU2pOEE3HFQELcw/bAUny1DmUevH7fdBLXlV02qlO9DNV3ffc+6nWH594zwd27W31WDgCplMm+6TRXr7RveO7c3uLO7bYmKj8U5ejRHFLa3LxZ7ANXvSUEnHtmnC//3nz3sYnJJNPTKarVJrdvFcnlDCrVJqVi8HgbDZcv/s4c1YrDP/rf/ojjJ3LtcOoP7Of5FyYxTZ1Dhw51Uy5qtRpXrlzp6kMftRzHYXl5mZWVlR0DqjsAq7dqtRqjo6P86I/+KD/6oz/6pqx19urbX3sA6zGvQQar1Wpx4cIFXNcNCMyr1SpvvPEGiUSCF198sW96JiwbcKfpwg47ZVkWL730Uped6lxc3njjDU6dOtUngG82m7zxxhsBB3gpJXfv3mVmZoannnqKsbGx7nu2trbwh+f46P82xZd/aZOJoymW7zxYHFbnylhxsLdvfn0P7ly2SQxpVKs+Y/sNYnqU8myTunQZHljxstLCwcccWF5NhbmohsBLCRhgx2LoPYBMIJo61SaAzuW4Rzrenq7LtQS6EAwLk4r0AkAr7euUpEtmYFoxJjTWpcOIYvqwIN0AwAKw0mZgPwE0ByWSSLQEvibR5ABrh06jHmOokWV5XTITb+FFKowlbRzUYvIcfqjQ3Q7hnSZ2aAWG2UgkXRdfCBR2XGiG2qHeBNZsyahC3LWDbyiVlg+GINU0SZFDVnNcWfVoplpg1DidrwamA0ei4cxJLm0Sxm61vPBz0dTVNg66gE0/wqge3GbW9Dh5OM74oWGqVYc3Xgu3Ymh7WC10/91r5bCxXmdtrcboaKLPH6u3CptNyiMPIndOnxkmnY6wtFhhdrZ9t9Px2/r6q8t9711eqrK81D62Y8dzZDIRJD6z90tsrAePq1e3devmFrdubvF//uIl0hmL7/6effzJP7Wf73llPyMjCRKJBC+88ALQvq7du3eP+fn5N21yqgqoHh0dxXEcJcDqvaY9bHJxr94ZtQewHtPqaLAMw0BKie/7XbF4Pp/vm/iDBwDqwIEDHDt2rK9d2AE2g60627a5ePEirVaLF198sa9d2MkunJiY4IknnugzD7116xYA586d69NvdVqMIyMjff5bvYxWhwXrVIc5O378OO97336OP7vAZz5xjSfGh5m/WqS25dIoSkaP6azdfrCYSR9GJtNU14usLrpAFQRolmTOrpGSJllpIhAYaNRTHuYgaGrotPCIDLBVdsUlpmCGnBBF1FbDwaw/0G3FspAwfFpNl5QMruhbCoAFtKfvFFZfkbjRcZvo35+yAwpfrSFhtEX2A3oSXQhWfZsxxXv0iLbNbgmi9SjUo1S3YEtrUEjWySVbHOlxkwco6QYxBbuViGqo2K0osOlIhhQ6rJ18slZtyZgCLLXBnXrxLLlq49NxBUvWKVVbLurqRLfizMkUcxsO5ZiNa1Q4PFRnLO4xFPNp+DoxhT+V6YSzW7oIX/Q3Sw6HRtXPrZYlowrmC+Bg2uVrb6xS3GqRTlscP5FHCLh9a4tisQ1eXn55iq8OeFh1rBy42Wan9u/PEIsZPPPsWMDKAeDkqTS3blXwtsc/OywXwORUkgMH0sQTJl/5/XnC6tChDJubjb6px4OHMoyPx9ncrHP3TokTT6h1WwDlks1Xfn+BG9cL/M2f/H3OPDnM+z/QFso/fbZtA3H06NFu2kSpVOLq1as0m+EpADtVb0B157q8sLDA8PAw0WiUWq22J3J/F9YewHrMqwOiFhYWuHnzZmDibycApWrvdaq3Xfjiiy/2TQN2vLQGsws7VgsdRk0FlAZbjL2M1mCETkcn1sucvfzBaY4/nedf/f0vIUs2ZkqSSZnU13wmThksX3twsZ+5WKSGQ6JHfO47gorwQOiUZAOBJCEN4hUdX/SzNxqCsnAYGQBBGSwqOKQGRO15PYJ0g228iHyAOvQe3VYjodHQIBWTpBs+ye3PMUMYHrfmKt3kraZ6MR7GxJEScwCdRIRGJSpRJcrUQzRj8RDH+pwfo16y8Mo6NzSParRKLFnnYNJj01a7sydcF2VKM9CKWOAH2ydjyfBWYNGFMQVYSkmPMJVWNGWBF/wci3CQp3CX6Fal7qInNHL1KBClUpYsRz3ItnCcMs+ONQIs20QiXE81vIMxmOr1nYokwica440yxa02oiuX7e7UXycOZ3p/mtu3wt3ZR0ZixONm184BHlg5JBImC/Nl0lmNm9fLSg8sgPW1GmNjCb721SXicYPTZ0awIjr37xW7GqsjR7IUCk22tvq/oPdnStyfaQ+4fPf37KNedzn3TJw7d4pUBiaB02mL0dEEd+60Adqli+tcurjOz/+rNxgZjfEnXpnmgx86wEvv3UcmEyWTyfDyyy8D7Ru+jsnpm2W3XNfl1q1b/PRP/zTXrl2jWq12tWF79e4pIffcyh7LchwH3/fxPI/f+Z3fwTAMzp4929fC60zvVSoVnnnmmT7A09veO3v2bF+UxE7two6X1rlz5/qyCwetFr74xS/yXd/1XcTj8S5QGty/MEbLdV0uXrxIrVbj2Wef7WPObNvmG9/4BpVKBdeW3Hy9yaXfr3P/so3wBRFTIy5N5DbTI5E4+H2aKYlEmhKtxzdICGj5Dklpkpdm9/WO8DGEQAyE+q6JJqMySD/UYi6JRvC+p05Q5+UhcZHbrUkJUZ9kGmK2R97T+gT1AJ5svz6i8MpqmpKoQr+1FfHJtYKvv+83OagQ2S/4LfYpbB8c6aMjlJE1q7rLmDd4zJIls0wm1WIqZbOv56OkhAaa0r/qak1yWgHKXNkGripwEfYegKonSSredKsuOa5obQLMuoIDCiNQGxS8Zbtu1CVPhGxvThiM6zZFq0401p5KTGwHPa80DMYVMTcVB1IhXaTbRZNjWbWG58K6xdkRNcD6v65l+P9czQUeFwKef3GyK3gfn0hw8GCGRsPl5o1Nmk2P8YkEhq6xsKDoOW/X6TMZNjYaHDyYp1ZzuXF9E7fHxCwS0Xji5DAXL6wp33/kaJYDB9IUiy3Ov7FK2Mr20nun+NofPWDZNE1w/HiOTC7C6nKF9Y066bTB8lK46P+pp0e4cb3t8v7ce8Z45f37ef8H9nPiiSGEEH0Tfuvr69y4ceNN6aZ+7ud+jvPnz1Ov10kmk4yMjPADP/AD/Jk/82d4+eWX9yYJ3+G1B7Ae03Jdl0ajwYULFygUCjz33HN94KVWq3H+/HkikQhPP/10H4AKE5/vNNnX0XZ5nse5c+f6vLQ6gKxXmP67v/u7PPvss9y7d496vc4zzzzTB5Q6HluDjFbv1OHZs2f7tArVapVXX31VeaFzXZ/7FyK8/sUa965t4dRcEhGLhGHit3x8R2L0CI+auETQ+9gmd7ttpUuBRGIhyPgmjumTdfqX1k47cFC3taW1yPlBgNJIe8TKQRZoTTQZVgC1asxmJK6TxCfXFBjb52detpgWwe2HAaYZv8khxeOLfospBZBqaT4RX33R35AOwwoN2ErUZbwZBJW9WrKm0cJJVBhKtjgc97nfFEqh+92G5EiIFmvNF4wqfKOWhMGkVE/SzjSkcspx3YWREP7/li04bqkvq2Hs1mJLMqWYWIQgAPSEpJZ0cYwyut7iuTF1W6riGaR0FfjSSIX4ct0pGRzNqM/FG40h/u8XJ/rsGDQNnn1ugm98fVn5nmjU4Ln3jKMbGjeubXRZpsE682SGq1dKfaAombI4cSKPpgvm58qMjsS5dGld+X6A48fzrKxUKZdtsrkIx47l20z2zQLlchssvfTylDKGp1PZbIT9B9JEowaNps2dW1tde4hOPfXUMDdvbtFqBWm26f2ptqP8B/bz0stTxBNWHwhyHIfr16+zsbEReK+q/tk/+2ddYX08Hsc0TXzfJx6PMzs7GxoivVfvjNprET6mVSqVeO2118hkMpim2QdE1tfXuXjxIvv27eP48eN9AKrjvn7q1Cmmpqa67+ltFw5O9nVsE7LZLE8++WSfPUOYMF3TNC5duhQQ1Pe2/gY9tgqFAufPnw/ouqAdldExS1XVc889w0c+Morzdxw8z+NrX1zmN375Flf+eB3bdTENjWTEwGjq4EEUg5pwSPR4XRlo+AkfURMIBC6wqbl4vkdFc0hLk8z2VKGJRkOh28r4Fk08ogO6LVlV77ce0sJqNH0aDaut26Ltt5U0JbqnKztAYdvJh9g4jBoWvhfUYUV8jYJ0yCuAVFV6SoDl132laD4jDGxDYrmCqBshWopgl+CycFmLlqmmWhxO+SR7TtX4DkL3zabPqNKd3QEF6AFohEzqDekS2wdLoY73HT/U3dSJmuAFAcxYROBLlGL7QdylS0G6YgJDzOsGFystKkaFoVSNY7lWdxpxqSI4kQ1uL2X6/P/ZO+/wtuqz/X+O9rK8Z+Ls2NleCUkYIewAIQmUttCWtnS30LeDtnS/LS+/Au3bwkvL6gBaWkYhq0BJgUASGhIgsR07sZ3hJHa8p2xrS+d8f38oOrGsIxNotnVfF1cb6YyvZEnnPs9zP/ftkfXY9fEEIWcUh3hHYJCWIylMmOikYJyDocEANpsxIbmCSLjz3r19dHdFiNWUqWnk5trp7/ezt6EXIWDOXCe7awfi9nUPBdm5owOrzcC0qen4AzKLLxhHd5dXnTiMonhGBm2tboaGIh9WV39AXZdeLzFrdhbjC1PYvzdxCzMt3UxGhjUmvifawrRadRw5MojdoaOuvpdwSPv7eKR5iPq6Pv7yZB0Wi57F5xdwyWUTuPTyCUyYkIper2fevHlA5Less7OTffv2JbTKCQZjv3xR7awkSaMK3bds2cKvfvUrdu7cSXt7O2vXrmXVqlUJt/+g2Lp1KxdffDFz5syhurr6hB33XEOygjVGUVdXB8CUKVN46623mD17NhkZGRw6dIjGxkZmz56tmu9BrPt6WVlZjPu61+ulqqoKo9EY1y7Usk2AWEI2sv3Y29vLe++9R25uLqWlpTH7RFt/5eXlMaLPaMj0yFBoIQSHDh1ShfNaWLp0KUajkVAopApMo+TM5/Px0uptbF47wOHdQfo7/ZglHU6bGb0f/IqMRY5tHwZ1CmYlliANESQFE4pQ0CGwCQM2occq6ZFGtPIStQ+1bB8UBGEdGEa0IIMoGJDi3N4DkozVDk4bOPwyzqPr9AsFk0YLTxGCICLOHR5IOJXYqg8xTtaYVrQrZHjijxM4em4tE8YOXYg8Jf5Y0VakQGHI4sVg9zLeESLPDP1hQboh/lh1HsGsBK3AobAgRWOfw4qeSRoCc4CWgGC8RtWpS4acBNOEo7Uj+2SJDI2Ym56gICsBYav3CmYOI40hvUIgLURIcYFeZkGC6tZhj5lJdu0JxIGAjlQNby5fWOKCtRMQSGq77mCji6IZGegkif37+3D1Hzvm1Klp9Pf76evTXkN6uoXpxVYGXSHa2gIMDsZXlh0OI4UTnHETh9nZNqZMTSMUkgmFZA4eHMDjTtyCG165ys+3M3FSKn5/pA3p98squTrY6Ep4jJLSHAZcAXLzbQwM+Diwz8VIXjR/QV6MI/1wTC9K49rrprBwUQHnLczHZDLE3AT6/X7q6upwuY6tYTgpslqtWCwWgsEgmZmZNDU1JVzrK6+8wtatW6moqOCGG244oQTL5XJRUVHBtGnT6OzsTBKsUZAkWGMUsiyrd01bt25l6tSpdHZ20t/fT1lZmeooDLHu62VlZTHu64mmAYdH28ybNy/GjNTn81FZWYnBYKCsrCxGmN7c3My+ffswGAzMmTNHrVAlav0Nt4EoLS2N8exSFIWamho6OrR/8CRJ4oorrkBRFMLhcBy5crlc7Nq1i5ycHLUV2tnq5rlH69i8vpnuZi+SgNQUM6aQhDhqyRBCQQfoh5VlhCRAB1LM+LwgKMKkCCPpwoTp6PaJdFvdkp9sDeLlS1UwD8QTlz4pQIaIbyEMSMGjlTSBMEf8thxhBYNBwumLv5AfUQIUarQDe+wyWZ54JtGhD5GnQbDcQsaRwL+rV4Q0A6wTtSh9OgWrRivSY/DhsboZ7wwxxS5iCmPdkp5srcwj4KBPaLYcO8KQl6DOX+8RzNQgSyFFoJOIiz4abR+Aw2GJSRraLQUIK0KzWtbsF0xIMLnYojfgMHkJGAYpTPcxIeUYAanqMVOWpU2w2sJ2CgzaXk/LXhrPoBRxUt9dG9uu0+kkimdkkJZmIRSS2b+/nwGX9jkA5s5zUlsTsV0wGHQUz8iIsWNwOk3kFzjY25C46jRrdiZtbW4mFDqxO0w0Nw/Q2hJrQTHcimEkLBYDJWU52KwG6ut76WjXft0lpTk01PfGtAXtdiNFxRno9ILDB13k5pmo26ORtn4UObk2jAYdra1uUpwmLloyjksuncCll08kO9umardqa2txOp1IksTNN99MbW1t3LHy8vJobW09Lg2WJElxBCsQCPCjH/2IZ555BpfLxZw5c7jvvvtYunTp+x7vpptuYvr06ej1etatW5ckWKMg2SJMAkmSaGhowGq1xnhLwbGonKysLGbPnh1DoBJNA44WbdPf309VVRW5ubnMnDkzxp4hKoCfP38+DQ0NqgFqtPU3UvM13PR0pGfXcDG7Fmw2GxdeeCHhcBhZlpEkKYZctbe3U19fz7Rp02IqYrnjHPzX/5zHf/3PeXg9IVb/sYENzzbScmgIWVJIsZqwSQbCIQUleCwvUBISXjmELWZyUEKS9HglBb8IIFAwoSNNMRKyS9jcsWQkXWiblAYHwpg15NNWu0HL7oiganEgIQX0uLvBjZ5BS4BcuyGi2wpIqvu7ksCqIDQkR1xZR8CRIFzaIenxmQTWoEZbzRbvGQZg0bTuBKuiw6dXsMojchfDVroGJIJDFmqlMF77ECl2P1McMilSGEVCU2ifuBWIZk4kgMGUwCdLtX7QOF4CITuA56hP1kjoAI/BgEljCjJzFDukgDvEeKsJyCI4BLVmGbfZS4p1iHAi23ugsz9MQbb2czNyBF321DhyBZHQ5fq6XmbOyuTIkSEcDiMzZ2bi84VpqO+JMQydMy9FJVcQ0UAOt2MoKk6noMBBX68fk0lHMBj/B5ozN4vGAy58vjCu/mPrmTDRybhxDoaGgqQ4zTGC9pGw2Q10dnjU6cLJU1LJy3MwMOBnb0Mfsiw0yRVE3OirKiN5iYsWF9Dd5WXR4nx6ejw0HhiM0ZNlZlkwGnUq+RsaDPLPlw7xz5cOIUkwd14W3//hQhZfUIAsy+h0OgoLC9m6dSsA6enp/Nd//RePPfYYXq+Xjo6O/yjs+fbbb6euro5nn32WgoIC1q5dy7Jly6itrWX69OkJ93viiSc4ePAgf/3rX7n77rs/9PnHCpIVrDGKaAWrt7eXHTt2kJaWxoIFC2LuiKJROUVFRUyYMOG4pgGHV5pGiuOjxxvZxovaMwwXwL/zzjuMHz9eDTsdSeI8Hg+VlZVYrVZKSkqOW8wOUFBQwJw5c9RJSp1Op/4X1YUdOXKEuXPnxgj/R4MQgn+9cJB1T+xjb2UvIb+MzaTHaTYjhoRq2zTS9gFAscvohleCBISFjFGSSBXGmExDn1PBOhhLKgQwqGH7IEsCCeKMP7UmEkeuTUHGnBbRbdkVcGoERYeFQCAwarQPvWaBTWOfJiXARI1qWLMS0Ayd9gsFc4L2YSLB/oBNkOod2epUGLJ6kGwepqcpZI6oFLXpjRRo2C4AtAcE+VqtQJ2BHI1Aakg8ZRhUBIYEJG+0ScK9XkFxgucGZXBqFAZHay12GHUYjG4kk5uiTG9MRuGOLjPzc7QrT8/0T2GLJ4/Dhwc0qz1z5kbahl7viAB0q4HiGRmYzXoCfjfV1YmnCdPSzWRmWmk84AIilaLiGRkYjToaD7jo6fExrySbfXv78fsTZzwuWlzA7t09FBdnoNdLHDjQT1/vsXZlRqYFp9OskquRcDpNnLewgCF3kL31varX10gsXFTAO9tjK2QRkX06oXCYrk4P4bBMV2fiqcRlV0/moccuJxwOUl1dzZQpU8jKykKn0xEOh8nJyaGjo0PVqfp8vphBodEwsoLV3NzMlClTaG5ujpGBXH755Zx33nn84he/0DzO/v37ufDCC3nrrbcoKiriZz/7WbKC9T5IVrDGMJqamti3bx8Oh4OcnJyYalJDQwPt7e1xUTnREGVFUVi8eHHMlzzaLhxZaRrteMPtGYYL4HU6Ha2trQwNDVFRUUFGRkbcecaNG0dxcXHMxff9xOwlJSXk5uYSDAYRQqDT6VSPrqjObHBwkAULFnwgYz9Jklj20aks++hUAHZu7eDZh/ew+50uXIMBrAYDqVYTdp+RgCLHaLQkjw7ZKNBHbRIkMEh6BgkipIhoXAfYhR7HkAEhiRjdlkREW5UyIlxaLyR6JH+c87wNAz6TjDUYe1W2Y1T9uXToCbmgH+hDQUlVSDeDw6eQdtRvyyBJtCUIl+7yBTSnEhMh22DUTJ62SDpcepk0OZ5BhIXQrJSZvfFBNjpJR6o/hY6wlc4+PY1GP8LuJscRZKJVoPcFEwrTB2TI13jcGgxpVpwAJKN21I9JJ9EdFGRrVLeybNoVMYDwKLfBXoMep0brM8MYIXRarUU8MlkmG3ht9LgER5wKQ4qLgjQvJo1JS3UdXT1sr4m8rslTUsnPc9B3VLA+rySHhoZeAv74tfh8Yaqrupg1J4W63UOq2L2v18u+ff1qtSczy0pKikklVxCpFFXujFSKJAkuvmQC4ZBC4YSUGCPR4Vi0uEANkN551HV+uKP80GAA91AwIbmKvL403tpyhEBARqeTmDEzk4wMC52dHnV9w88zHBGRfQeZWVacKSZSUw1MnmyivX2Q5qZYYnrx0gIe+cNV6HSC6urdZGVlkZubixACIQT79++PvPfDBF/HS660UFtbiyzLFBUVxTweCATU3+bhv32f+tSneOihh/jEJz7Bz3/+87j9kkiMZAVrjKKlpYXa2lrKyspoaWnBarUybdq0GLPPsrKymLbbwMAAVVVVkRDlYU7vw6cLZ86cGRNtM9zNvby8POZ4WvYMEGn9vfXWW0iSxMKFC2P2aW5uZu/evXHnOR4x+5IlSzCbzZpi9qiNhE6ni6u8/adoOuDib7/bw9sbWnB1BDBIEukOM/oAiKM31AFkjOhiROlCihCI4VosRQhChHEKIxnCpNo8KAgUA+jCsRfTfoKkaxAgrUoYJNZ5dUk+ckTkR12YZFJSwSErhPWCHF88+Ulk4+A3CCzhBEQmgQN9IguJDhEkT8M1HsAlwqRpHKtVH2ScHLtPQBfEZ3OT5vAz3QnGESTniN5IYYLqlissSNMgWU2yjol67b7jfq9g+gesbo3muzWaeL9P0pOhQb7CIqJP0zpXn1EQNA7htHsozvRhHvbn3dxm5Ztbc+P2WXzBOGRZQQ4L9u3tZWgo9v2SJJgx00F9XXzPOpo9KEnQ3+9n315t0gRQWpZDfd2xdl1WlpUpU9MIhxXVFV6rojQcmVlWHHYjXm+YKVPTCAZl9jb0xlTdErUFo8jJsVFSlkNPt4+Ghl583vhKWkamhZQUM02HY0lcbp6dSZOceDwBnKl6vv7NcchyEJ1Oh91uZ/bs2SrB6ezs5KqrriI1NZVt27bF5LseL0ZWsJ577jk++clPsmfPnrhIHofDQV5eHgcOHFAfczqdmEymuIBqRVEQQqDX63n11Ve59NJLP/DaznUkK1hjFPn5+TidTsxmM+3t7ciyHGOnUFFREfNljvpOjXR6H6mdGt4ujGYXarm5R/2yRtozRPeRJInx48er5Gp4FWzked5PzA5w5ZVXoiiKJrmKus5nZGTEGJaeKEyclsYPH7gAAFevn2ce3sMb6w/T3uRBkgSpNjNmYSAUlpGCqN5akpDw68JYhn1NdZKEDj1uScErAoCCGR3pihHJrsc04oY8HRMewthHfNX1gwIZEWfPkGYyacbbWcWx/aXgMd2WXx/GnQoOnUKaH1Wony0ZURBxU4yWsES/CJOuQX5cQtYkWM4UE2hoj7MSnANgUMiaBMuqoekyKybM7gyGZEFDh8BtHcLi8DPRESbDCCF3EBLYP/SGIE0rlUiWE1qmJ3SB10lHMw7j98kepbo1GjwCMjQeN0gSPSFBloaGyxEAQ9CJzuvkUI/A7Qgi6waYmuljgiN+3fMX5PHeO+2EwxFCaTDo1PzAliODtLYOUVSsTa4gkj3YZBjAaNLT2eFhztxsUlKMtAwLjwYoL8+ltrab0LCU654eHz1Hg6RNZh2XXjYBrzfM+EJHjF9XFJlZVux2o5pp2N0dsY8wmXTMm5eN3WFCCIWqyq6E5AoidhOv/eswAGaznnkl2djsRo40D9La4iY9I3H7sbPDQ2eHh4uXFvLnv12HJMns2LEDvV6PXq/nySef5He/+x2LFi3i3XffZeHChTz99NNxZOjDoqysDFmW6erq4qKLLtLcJhoBFIWiKHFi+4cffpg33niDF154QQ3ETiIWyQrWGIUQQvVY2bt3L4ODg7hcrrhq0nDfqZKSkhjfqeHtwvLy8pjpwq6uLjW7cLib+/DcwPLy8hi/rKj/1oQJEwgEApjNZoqKigiFQlRXV2tWwd5PzG61WrnoootUzZkkSej1epVEdXV1sXv3biZPnhxDHE8FQiGZf/xlPy//7QCNu/sRQYHdasCuN0Z0W0e/mVq6LdkhI7lH6rbCmNCRijGmXehPUbAMxROLXilApsaUoUcfxh7nrJ5Yu+UmhAMjCgompyDFLMgIQX84RJ5G9SxRRarPoZDhjl/nkAiTopWtCLiMMmmh+AtPonOEjlZutETr8fsI3CYvss3DhDSZcab4itRhDExCWweUKKz6UFhissa0IEBjAKZqeEfKQiBANYwdjkQTkDC6LcRoBqvahqiCAbPM12r1BI/2LM9bmM+O9zpQlAQ+bXqYOduBTjKgKIY4d3aA/IJItSYa0jwchROcjBvvwGTW8862Ns32I0QqZAvOy48Jfy6c4GT8eAeDg0H2NvSSlmbBZjfS3DSoeQw4ViHLzbMzbtyxfYevOVFbMIqZszLJzbXR3e2L2zeKCy4cz1+fXYHBINi5cyc2m405c+ag0+lwuVw888wz/M///A+BQACj0cgVV1zBNddcw7XXXhtj4JwIbrdbrUKVlZXxm9/8hksuuYSMjAwmTJjApz71KbZu3cqvf/1rysrK6O7uZuPGjcybN49rr732fY8PJDVYx4FkBWuMQwiBy+XC5XJRVlYWY6cwfEpv5DTgaO3CqJfWnDlzyM8/pl4Znhs4fFpxeIsx6r9VX1+PLMtqRStqODq8qvZ+Yva8vDzmzZunTgqOFLM3NTVx8OBBZs+eHVNFO1UwGvV85PMz+MjnZyCE4K0NR3jh9w00VPfgJojNaMBpOarbkmXMwzINJbcOYQYpWm2SwCAZGCSIgo5eEUKPwCEMON0mZJ1AP8L2IZHUxqvEV7wAZKvQnPTzSmEcItLgDA9GdFv9CEKpgrAZHIFYDZVJr9MsxuiHFNAQzKdIhoTtwyFZJo14gpVmMqLFe4ySFHGUJ75047CbRrw+CUfQDkE7rYMKHVKYkH2IdEeAyTYFk04i4A1BgtZdVwgmahQdrIpCoozDiHYrnkToJYn2oCBfq7o1irlqAokYAGFJSlgU8+m1NGQSqQED4xx6MqZlkp5uYefOxOTKaJSYOMnK7ppjxCklJRISrdNFfLPsdiPhsKCzQ9se4UjzILl5Nt57px2bzcicudnopIhgvf+ov5YWuYrue6Q5QqYmTnIyblwKoZDC0FBQ3Xc4hrcfm5sGVSIWdZTX6yP+X29tSTyVmJpqJhiU2fTmEXXfouJ0DHo9jY399Pb4WLS4gL88fZ1KrqxWq0quIq9H4plnnmHJkiU8//zz1NXV8fLLL/OnP/0Jt9vNN77xjYTnj2LHjh1ccskl6r+//e1vA/CZz3yGJ598kieeeIK7776bO+64g9bWVrKysli0aBHLly9/32MncfxIVrDGKIQQeDweampqGBgYICUlhQULFqjPDyc28+bNi5nSi7YLp06dyuTJk2OqU7t376a/vz+uOpUoNzDaYuzu7o4xMN23bx9DQ0P09/dTWFhIUVHRBxKzz507l/z8fE0xu6Io1NfX09vbS2lpacw6zxQ01PTyzO/28O7GNoZ6gxh1Ehkp5kir7OgwUoAwevTxuq0RfluKUJAJ4xQm0oUpJvInbBUYRnhfaenBAAImGXMwnjEMECRVo1IVrWwBKMajui2hYA+CSdHOJUzUPkxkUprIo0sWkRRkLRlUk+JnokZ1q1+ESNfw4oL4icUwYTw2D5LVx7xMgU1D0H5Q0TNFw6RUEQJZROwcRqJZ6JkgJTA2lQyMT1BxSlQta/ULxiXwyRrNk2tvAIoTpLD8v2YF67yIt9Qx7yszHe0eDh1tiZlMOsYXmjnYqMHIj2LS5FTS0sxYrUY6OtwcOhjfTltwXj6VOzuQR9hKRPMDMzKtmC163tzYnPA8OTlWzGaD2m7U6SSmF6WTmWlVBevvp7mCiFnp9m2tTC+KCOW7uzwc2O9Sn3c6TeTk2uNc5qOQJFixajq/eeAyzBYdlZWVGI1GSkpKYuQKq1atIjU1lfXr18dF4URd3JM4O5AkWGMUPp+PrVu3YrVayc7OpqurSyVY0VbdSGIzvF040jw0Wp3S6XSUlZXF/DC0trZSV1cXZ/cwPJ9weItRCEFlZSU9PT3MmTMnJpLneMTsF154IVarVVNvFRXdy7JMaWlpTFvzTEVXm4e//W43b710hK5WL7owpNpNmGQdwbCCPiTFZCIGDTKmcCwRkhEoiKMB0AILEunChOSUMGmYlCZqHw5p2EEAhIwKxlD8cTRtKSQZUxakiohuyzyM8PXYFbI0iFQiGwePkLEnMC9tF0HyNUTwLVKQ8UJbHO8XiqZrfa9DIVOjfSkQBIVC0OJDb/dS4AhRcPQjNRqBSZQ92BEQ5CXIJKzzwiyb5lMJDUeDIuFwJId9gkkJql+jCfvftDp5eKdL87n8AgcTJjgIBNzs2e0hlCBSZuKkVDzuoKqfgmMh0V5fmL31PZSU5rHjvfaEFTKdDsrn57Hj3Q5y8+xMnhzrzg4RcmUyG2g5oi0hADj/gnEoiiAQCFNf34vfF0+yEpmVZufYmDIlDVmW8fnkGC+vkSivyOW5F1ZhtelVo+XS0lL1t8nj8XDDDTdgNpt58cUX/6NJwSTODCQJ1hhFVGg+btw4Ojo6OHz4MIsWLUoYlTNaTE2i6lSUkLW0tFBSUhLjKTU0NMTOnTvj8gmjFa329nacTicLFy5U9zkeMfsVV1wBoEmuogHWKSkpMW3NswleT4jVf2rgX38/SHPDIIQFDpsRq2RAcR/TbXkZaWoKil1BN5y8CFCEjAGJNIw4hum2AlYZs8Z0YKIYn15DgMxwPAFKNJXYLfnIFlYECganIMUS0W31BIOM1/C2Gs0F3m1QIuamI5DIBX5Ir5Aix28PiUlZmxKkQKdNykZOM3oNAcL2ISy2MHNTZI0GJuwPSkzXCIQeTWvVqjMwLoHvVovOyHhFmxD1hSFDQwwyEBakJughjhaavaFP8KcO7cuGzW4gK8tAc5Nf9a8yGHQ0NrroPUqmpkxNwzVKhA5ESI/PF8ZkOuZ9NRx6vURpeS47NWJpLBYDM2ZmYLebGBwMUDtKQPTIqUSzRU/xjExsVoPq9fV+AdEpKUbyC1I4fMhF8YxM7I5jYvco5pXk8MK667HbDeqNaGlpqfob5PP5+OhHP4qiKPzzn/+M0ZkmcfYiSbDGMKLts66uLvbu3YvT6dSMyhnN1DNRdSoUClFTU4PX66W8vBy73a7uk8ieYbhFRF5enpp5FX1uNDG72Wzm4osvRpZlZFmOI1e9vb3U1NRQWFjI1KlTz4kyuxCCfz1/kHVP7uPA7j68AyFsRiMpZhPCKwgqsbotgUCySnE6KjdBHEdzEvWAQxhIE0b8RgXrCAG5/2j7cOT0YaLKls8UxhpMLIwf8YoQFgVnCjiCMukjvK/cRgWHRpUsUcsvkVUEgE8oWDUqVYeFn0mSRjRPgu0B+hyCDLeGESsCWZLx29w4HD4m2xUcR9+KPV7B7ATarbaAoECjihVxh//gVg3NYYkJCUT1Xllg02gt9gYFmQnOddhg4mG3Oa6l53AYSE/Xc+RI/BiqJMH0ogzGjXPQ2+uLCVQeiUWLIzYL0SuTJMHUaelk59jo6fZy6GA/80pyVW8sLeTm2jAcjaWZMjWNvFw7vX0+9u3tU487klxpYemlEwj4wwwMBGio70UZ0Ql2OIyMH59Cg0acTzQUO8Vh4rePXElKipHq6mqEEJSVlankKhAI8PGPfxyPx8O//vWvD+S/l8SZjSTBGsOIEqz29nZqampIS0ujtLQ0pr3X09NDdXU148ePp6ioKKY6tXfvXlpbW+OqU4kI2XB7hrlz58ZMw0QNR51OJ3PnzqWzs5PW1lbOO++89xWz5+bmUlJSoilmh4iD/L59+5g5c2ZMVe5cQ+XbHTz3SB1VWzrwusKYjBJpNjPCAxx964LIGEb6bSEQRoFuGHlRhIIsZJwY43RbwVSBaUDDGoEQTg2SFdDLmDWMQrVJFvRLQdKFCcUg40iDFBTS/RLNirZ5aSIdVkgnMCjEtE+jaBUBxmm5wNshVVtvnVBon8idHqBPhMg4qutShILbGgmmzsiAKZL253mvT1CsUT1ShCAs0DQO7dAZyEtQ3UpULQNoDcM4jerWaOfqCgpuOyDU0GSvL0xrywBmM7S1Js4eLCrOoKPdzeBgkJwcG5OnphEY0dJbdH4B2xPkBgIYDBLzF+SjKIJwWKGhvjfONT43z45eL9HWquG5lWFh2vR0rDYjNdVd9PcnrqKNrFylpkXc2SVJYt/ePsJhmQkTU+OCqIdj5qxMVq+/gdRUkypNKCsrU/WgwWCQT37yk/T09PDqq6/G3NgmcfYjOUU4xtHf309dXR2SJMVE5Qyf7Js1a1aMDmrkdOHw6lQil/XhAviFCxfGCMu1LB30er3q1TKamH3mzJkUFhYmFLPv27ePjo4OKioqVAH9uYry8/MoPz9CWo8cHOCp/9vN9ldb6RnyYdBJEb+tsJ5gWEYK6475bSERVpQYhyidpEMn6egnjFcIBAoWoSMDE1JAu5ITkMIg4gnTgBIiR6NRpnPoNLMSw0cF47qwHm8PeNHTLskYM810SAppvtiMwlyDSdMF3qhIdIsQ2RrC9WACF3iDW4YErUiPXiFV4zyOBJWtyJN61cNLJ+lw+h3gd9DXK9NrCKI4PGTbg0yyKcdE/1rO60Q80LqDgnEaXM7gDyUUW4VDSsLnFJMBNIiZTpLoCQoKNM6VZQSjBO3tHtrbPaSnm3GkgNNpY3xhBo0HjrUDo5g5K5Pm5kE87gip7Ory0tUV8aCKBi7n5Nioqe7SXCdEphLnzM2JsUhQPahsEW+rqAhci1wB9PX5CQRkdlV3oSjiqOeWiZYjgzGeW1ptwQFXgB1HW5IpKUZKSnMRAiZPTlXF/cNRPCOD59deT1qamV27dhEOhykvL1d/n0KhEJ/97Gdpb29n48aNSXJ1DiJZwRrDaGxspL6+nkmTJnHo0CGuvPJK4FhkTG9vb8xkHySeLhRC0NzczL59++IImd/vp6qqCkmSYgTwQggOHz7MgQMH4iwdOjs72bNnj+rVpYULL7wQm82mkqvhLcFQKERtbS1+v1/NNxyrGOz38+xj9WxcfYi2g24kGVLsJsyyDsUrVKKlKUi3KOj8I3RbRHRF6YoppgKlHJ1g1MmxF/NElSq3LoRDiX9cax0QIV4SEV5kTBE4rJARjoRHJyJSiVp+LpNMmsZEJCR2gU8kwFdExLRVK5MxkQ4MYEjIpBwlcwEphN/uxunw40zTUZigGjVaXmGiScJunZ5sjaBoGN0nq0nWtpkA+FajQksg4lZuMMh0dR6rxkXbgVlZkSk9i9XAIY18wuEYTmimTksjJ8dOb2+kpQeRqcRZs7OorkpMwPILHGRnWbE7jAy4AjQ0xLf0RpsWLCxMYXxhCna7kU1vNmv6VwFYrHqmTk2PEbQPr+btre9hwoRU1vzjI2RmWaipqVE9/KK/l+FwmC984Qs0NDTw5ptvxsSHJXHuIEmwxiiEiHiwjBs3DpvNxqZNm7jyyitVHRREDOqGT9klmi4cLfx5YGCAyspKsrKymD17dow9w549e+jp6aG8vDzm7k1RFHbs2EFfX7yuIYqomD0YDMaZh/p8PqqqqrBYLMybN+9DxUucqwiFZF58aj9rnthD8343YZ/AYTJiNxkRbgiIWOd4AOzEOan7CGPFgCJk9EikCAOpwojbHCYloFHFkoKkakzuJSJfIYvA6NeIcZECZMRMNwqEWcGaDml+mYwR05P9VoV0XzzxieYYGjTKWIk0XZ0iSG6CaJ4Bi0KqP/48o8X59JplMgPxDGZIBFGsfswOHxMcYbKG7X5YMjApgVVDoklCtyxwJHCVHy2C5zB6Jml4cgH86ojCYasFRcj0dGu3OgHmzstmwBWgYJwDny9MQ30PgUAs61l8wTi2bdUWkWdmWSkqSsduN/L21taEJK2gwHFU7nDsg5qaZqaoKCMybLO3j8lT0t7XiuH888fx9tutqveVThfruWWx6Jk2PZ3dtYmnBWfOyuS51avIyrJSW1uLz+ejoqJCJVeyLPOVr3yF6upq3nzzzZhp7CTOLSQJ1hhGKBRCURTC4TCvv/46CxYsoKamhszMTGbPnh1jHhqtNI2cLowSsqi2YHilKFG8zmgO8O8nZjeZTCxdujShmL2/v59du3aRl5cXoxlLIgIhBAcOHKC1tZV58+ZR956H1X9ooGZ7F4EhGZNeR5rDhHCjGnVGW3aGETEzskVG7x+WTSYUEAoODKQLE/rhui2ngkkj+zDRVOKAJUiqP56YJJpKdBEkDROKXsaeBimSQnpAIqwIDEiazu09hjBZ4Xjy3WYIURCOJ32jTfglqm4lsn0AOCT8TNaorgF4hYxN0gMCt9EPDjfj0mTCKEw0av9kj2YLkWhisB8d6Vr9VUavlm3UGfm3pKe5KcTgoDbBKimND3+2Wg3MmJmpTgdOL8oYdULPbNZRPCOTml3dmM16imdkqO3AqPN7wTgHiiLoaE8gniMSsxMMyThSTLS1uGlujndzj5KrkYj6ZmVlWdHrdWzZfCTheSZNTmXN+hvIy7eze/duPB4PFRUVarapoijcfvvtbNu2jU2bNsVU7ZM495AkWGMYUYIlhOBf//oXOp2O6dOnx5Ch4e3CkZWmqDA9NTU1xmohmgDf3NwcF6+TyJ4B3t+ZPTs7m7KysoRi9ra2Nurr6ykqKqKwsPCEv19nO6JVw2hM0XDtHMC+2l7+9rs9vPdGG67uAEZ0pNpN6IMSwbCMQY4Vx8s6JUKiRlyf3QSxCyMCBavQkY4Jo9ARRME8QovlI4wFfZwQPVGbMGRQMGpYMigcbdMNI3UKMuY0sJoFmR4Rl0N4RBekUIknccOF6SORqIqVSGgP4DUJbMF4otKiBBifYJ9ufZhsjbiiAZ0f7F5SHQGm2GUsw/RabSYzBUFtkXmiOJ0IaZQ0Hd9b/ILxCUxKt3rhgcMKkgTjC82kp1vo6wvTciRCcsrKc9izu4dgUJu8QcSKobvbS1a2Lc60EyLVoulFGQltFiZNTmXiJCc+n8x77xybOhwJrWnB8YUpFBamMDQUoqG+hwXnFbw/0SvOpKamm9xcG5OmpBEIyDTU96i+WYUTnKx98SOMG+dgz549DA4OMn/+fJVcCSH41re+xcaNG9myZUuMjCKJcxNJgjWGEQ6HCYfD7Nu3j0OHDjF79uwYYhLVTkF8uzCR1UI4HKampga32x3nlxXdZ/LkyXFWCe8nZp8xYwYTJkxQSeFwMXu0KtPS0sK8efOSegYNRG0zQqFQnBGsFno6vDz7aB1vrjtM52EvkoAUhxGLbEB4j/2NtIiQMAhEGJWMCRExOdUJhSxhiYvhCTgUzBomnonain6rgkWj7dcr+cnU9NzykyVM6B2CFBukhyOEZ7SWX8AgMIc12ocEmIiGAeswPdVI9DsE6Ro2DoMijDNBxmKiLEU4ZhkRRsFjHcLq8DEtXdDlkxNmEo5m4xCJ4Il/LgAarzSCBq/gJ4fjv6uZmQamTEvBPaiwf/9gQh2Tlog8atoZCMocPtTP+PHOUVtx48Y7CIcUOju9pKWbmT49A0UR7Nvby9BQ5CbteKwYLlwyHq8nhN6go/FAP329sZOFJpOOGTOzqNkVr/8yW/TMmJFJdo6NX9y3lMLCFOrq6nC5XMyfPz9Gb/q9732Pl156iS1btjBx4sSE60ni3EGSYI1h+Hw+Kisr8fl8BINB5s+fr1aootoprXZh1Gph3rx5MRl+Xq+XqqoqTCYTJSUlMXduiewZjseZ/YILLsBut6vkKpo6D8emE4eGhigrK4uryiRxjChbLBbmzp37gTVpfl+YNY838MozjTTvHyTsV0gxG7EZjChuBR/hOFNTYQdpRMdGRkEI0CFU3VaaMOE1y9g0tEiJTUq1Hw84FcwabUgt+whhknGkgj0kkxnSxfmiJXKOb5OCFCRwgU9EskYjS34pMp05Es2KnwkJ9ukgqBGiLeg3ejE6vOQ7ghSOmOloN5nITzAwstcrKE7QChyQIVWDNw6GBZ/fF3/pqKjIobq6G1kWWKw6JkywYjIZaW72MjgQOf/7GXfabAamF2WABFaLgYON/XR1xU4lji90EAwo6iTicBiNOoqLM8jNs3PwoEszgieKkfovSYrYSWRmWuno8NByZJCZs7PYNZq4Pt/O2hc/wsRJqdTX19Pf309FRUVMMsWPf/xjnn/+ebZs2cKUKVMSHiuJcwtJgjWGsWvXLtxuNyUlJbz99tvMmTOHzMzMhNopWZapra1VDUBTUlLUY/X391NZWUl+fj4zZsxQ23aj5RMejzP70qVLMRqNms7sfr+f6upq9Hp9DKFL4hiGhoaoqqoiKysr5u/yYSGE4LU1h1j/533UvdtDyCdjNuhx2kwRy4WjhQKB0GwJhi1hDP5jBE8RCjohsKAnU5hjDEyVo2nUuhEh1YmyEsMo6CUJScSTBb8kYxHxTKFXCpAuGTClhEnVS2SFdOiFlFDo7kfBjKTprTUyrzCKLhEiJ0HL0WUTpHk1xPyjtCmbCTAhQW0pGh3k1wcI2t1kpASZYldo9QsmJmj37QtKFCXwyUrUWgS4da+Ce1hh6LyF+ex4Tzv8WdLB+PFmCsY5aGvxc+SItl7KZjMwaXIqdXtivaWmTksjJ9dOT7cPvy+EPyDTrUGuohheuYoafg4NBmmo71VzDUcT10PEFqJifj5CQCAQ69cVRW5uhFxNnpJKQ0MDvb29zJ8/P6baf9ddd/HnP/+ZLVu2MH369ITnS+LcQ5JgjWEEg0EURUGSJLZu3cq0adMYGBjQ1E5Fswb1ej1lZWUxZKalpYX6+nqKi4uZMGGC+nggEKCyshKA8vLymLbU+4nZo6RqyZIl6HS6OHI1ODhIdXU1mZmZzJw5Mylm10DUvX7ixIkxodwnEtXbO/j7I/Xs3NLOYF8Qs05Pqs2Mzg+hsIJOECN2Fwh0ZgkxQirkIYRVGCCq2xImTOjp0wXIUOLJRPw0YQSJMhTdtjAOr4b1guQna1g1TEHBlCqwWBSyPGAj/nOVyBKi3RQmX8O1fjRxfCIbB4EgJAQmDYF8ouoaQJsIUjCi7RkmzJDVjSPFzySHTOqIJXYYjOSFtXWPo7UWHwpYCeam0dfvJzXNzLvbE+ugAOYvyGHHe5FKUEamgfx8K6GwxMEDQ4TDAofDSOEE56jGnYWFKZgtejIzbQSDMvXDNFBRjNYWdDpNFBVnkJ5h4d3t7QwMaGvWDAaJufNyqKo85hZvsRgonpmB1WLg0EEXioA1629g2vR09u3bR1dXF/Pnz48Z9Ln33nt59NFH2bx5MzNnzkz85iRxTiJJsMYwZFkmHI6Mim3btg0hhGqGNzJrsLKykpycnJisQUVR2Lt3L21tbZSWlsZonwYGBqiqqiIjIyOmxQjvL2bPzMykvLyc1157jQULFmC322NsGKIeWVOmTGHixInnROzNiUZU8H8q3etbDw/yzMN1vPXyEXpbfOiIRIlYwnrEsA6PnzBmDWF7UB/GJB/T1QkiBC1LmLGN1G3ZZcye+IrUSMKkntMmY/HGbx+1m9CCVwrjsEo4HJAaEqSEIutN1PIbNCo4NaJ8ILE4frQ4H5dZIU3D1LVXhMhMUN1KNAEJUc2XnkGzB4Pdy4Q0mRyDQntAkJ8gYPqwomOSTluo/kibwhuuSLTNvn19TJuWrumuLkmw4Lx83n2nXfM4VquOSZOtOJ0WGuqHGBjQbmVOmODE5wvT3X2schXVQFmtBg4dGiA/307dnvcX17+9tRW9XqJ4RgapqRba2tw0HY60EvV6iZLSnFGjeLKyraxZfwPTizLYv38/HR0dzJ8/PyZD8De/+Q0PPPAAb775JnPnzk14rCTOXSQJ1hhGlGB5vV62bt2KxWJh0aJFx501uGvXLvx+P+Xl5TE/LB0dHdTW1jJ16tS4ysn7idmnT5/O5MmTCYVCVFdX43K5yMjIICcnh6ysLNrb2zl06BBz5sxJ+sdoIKppa2pqOq2Cf/dAkOceq2PjmsMcOTCIEhI4raZIKLVHwUs4ThwfNgkMGtN2HhHCgh4jHPXbMiEQBCQlru0no6BAzDQhJG5ZQmLD05FaL8Uok5IKkggz3q8/5rw+7BwBITRtGbptCtne+MeP2THEI1F1S0GgCO2K2GjVrRYRiAvS9hoChGxDZKUEmWxT4o7ZjkQ+2t/Vf/QKDkyNn76L2ClkYrMZaG4eYNw4J++9q02uIFJVysq2cLBxUG0lpqdb6O8Lq63EiROdeDyhuNDn4Sgtz8HjDpGVZaNvRO5gFKO1BceNczBxkhObzcTmTU2EQtqvOyPDwur1NzBjZiaNjY20trYyf/78GP3n7373O+699142btxIWVlZwjUncW4jSbDGMBRFoaOjg+rqaoxGI4WFhUyePBk4vqxBm81GSUlJzDRfY2Mjhw4dihPAH4+YfdGiRTidzhgxeyAQoKuri66uLgYGBpAkicLCQgoLC5OJ8yOgKAoNDQ309PRQVlYWo5E7nZBlhRf/tp9/Pt3I3spe5ICC1WjAYTXCEDE2D1pTibJBQRc+pnsSCCShoBcSecIaFzztsYexe+KrUgnF8akK5oF48tMn+cnQ2D6Egk4nsKeBXSfIDILhqE4sUcahyy5I82hXiRI5x49Glvr18WHYAC4pTJrQrsh1WWVyfNpkrleESNFJ+I4GU09zKlglGAoLUrQ8HICDRjN37kpMePR6idLyXPp7/eTlxYctA6SmmsnOsXFgf7/mMTIyDUyaZEeW9ezZ0084AekpLcuJq1xlZFpiqmolpbmjiut1OiivyGPHex3YHUZmzMhEp5diJgvT0sy8sO4G5szNprGxkZaWljhy9fvf/56f/exnagX+ZOOee+5hzZo1NDQ0YLVaOf/887nvvvsoLi5Wt/H7/dxxxx08++yzBAIBrrrqKh5++OGY3+gkTjySBGsMo6Ojgx07djBz5kz6+vqw2+1MnTpVHen3er1xfkk9PT3s2rVLDX8+HgG8oijU1tbS3p74Lvayyy5Dp9NpitmDwaCa5ZWXl0d/f7+63pycHHJycnA4HGO6VRgOh2OigYaLbM80bNvYwrrH91H5VjtDAyFsegNOqwnJB0pYENKoNEkpIEbI9WQUFCEwABahJ0OYMKLDpw9j1fCQchEgTUMcnshNXpEEQhBH4ABcUpC0o9OEAgWjU+CwCAL+IJM1NGM+oWBB0vyMJrJxSBQuDYnblB+2ujXyOUUoDFk9mOwecu0y4zU+Tn3ouG2frGnFYDBIzCuJb7NFSU8opNDa6iYlxUjjAZfmmgAmTHQyOOjH1R/EatVROMESmUps8jE4GGklapGrkbjgwnEMDQXjTEqj0OmgfH4eO96NH7iJThYWFDj4/o/Op6Q0R60Sz58/P0ZO8eSTT/L973+fDRs2cP755ydcz4nEsmXLuOmmm1iwYAHhcJgf/vCH7N69m7q6OvW3+6tf/Sovv/wyTz75JKmpqdx+++3odDq2bt16StY4VpEkWGMYwWAQl8tFamoqdXV16PV6xo8fT2VlJVarlZKSkuPOGowK4EtLSz+wmP2yyy5TPblGkiu32011dTVOpzNGyxUKhejp6aGrq4ve3l5MJhPZ2dnk5OSQlpY2pshW1BnfYDDE/M3OBjTW9/PsI3t4e0Mrrk4/BknC6TBHWoXD7IhkIl5aI1t/PkMIa1RzdDQn0YwOs9BpiuADxjDmUDxpGSJEigbJCqQomIc0dFCGAJlhDT8sQqRYdTgdYA8ppA8zRe0RIbI0tFOjVZYStRCblAATE5ClHkJkaWU/GhUcCTRivQ6FTA0vMojE/aQYZRSHhyx7kMl2gY5IBuOXWwxMLc5Ep5PYv68PlyughjIPF4iPRHqGhZwcGxaLAYvVwOGDLjo7Y6cCJ09OZWAwEOdLBcemEvPzbXR1hTl8SPv3BbRtISZNTqUg30G/y8++vb2UV+SP2sZMSTHx3OpVlFfkcfjwYQ4fPhx3I/nXv/6VO+64g5dffpklS5YkPNbJRnd3Nzk5OWzevJklS5YwMDBAdnY2Tz/9NDfeeCMADQ0NzJw5k23btrFo0aLTttZzHcmQtjEMo9Go+l7p9Xo8Hg/bt29n3LhxFBcXa2YNzp8//7iyBuH9xezp6eksWLCAYDCILMtIkhRDrnp6eqitrWXChAkxZqbRtefn55Ofn48sy/T19dHV1cWuXbuQJEklWxkZGef0hGG0XZuWlhb3/p8NmDoznR89eCEAvT0+/v5oHVtePEJL4yCKJEi1mrCgR+eFIAqGERYJ5rABTEAQkECHnhCR6JxBScYAOIUB59Fqk0eRMWv87PklmRQRT0qG3EHMxJdvbAkqSykYI1NtPj2D6Gk1yDjSwK4oeAKyJvExeBVIoMMKp+gi9hcj4EgQvwPgTRB9YwtJhITAqHHz4R8MQQLC5hcKeWEruKwEXLDraDB1isNPSiDMzh2Rqo9eLzGvJJucXDv7GhLniGZmWUlJMbF3xDbHrBi8hMMKrv4A/f3x5ApAKJCelkJVZS+hkFCnEsNhicajU4mQWHN1+NAAhw8NIEmRbcIhhfL5eexr6MXtjv29stuNPPP8Ssor8mhqauLQoUNx5Or555/n29/+NuvXrz+t5Aoiv8kAGRkZAOzcuZNQKMTll1+ubhM1bk4SrJOLZAVrDEMIQTAYVIOfe3t7mTNnTkx16sNkDcIHE7NHndmHx940Nzdz4MABZs6c+YHyuhRFweVy0dXVRXd3N6FQiKysLFUkfy4FP0dzF8eNG8e0adPOqapdIBBmzRN7ef2FQ+yv7kMOCexmIw6rAcUlYryuEk0CxjyuEyALLIpEBua4XMWgXsEox/tbhVDQIWm2CcNGBYNGRchtDePwxa9n0Bgky6HHoVfICEqYhvl7JapUteiDjJfjpw8VIQijbeOQyMMLEk8z+vQKVlmbtPU5BBkaLUyA5+VedotI5cli1TN9+rFom8LCFMYXpjAwGGTvUf+pzCwrDodJndjTwtSpaQgB2TnWo1YMvfFWDOW51O3u1mwLWq06xk+wkJVlo273YMKpRK3pRqNRx4wZmThSTDQ3D9DfH+Dp51awaPE4jhw5woEDB+Iiw9atW8cXv/hF1qxZw1VXXZXwdZ0KKIrCihUrcLlc/Pvf/wbg6aef5tZbbyUQiLWkOO+887jkkku47777TsdSxwTOnatNEh8K0epUf38/aWlpMeQqmjXodDpjHMCj0TRNTU2UlpbG+GUdj5j9vPPOIy0tTSV3w53Zo9YPXV1dlJeXk5aW9oFej06nIyMjg4yMDIqLixkaGqKrq4uDBw+yZ88edSIxOzv7rDYmjVpVFBUVMX78+NO9nBMOs9nAzV+Zzc1fmY2iKGx6uZmX/3qA2u3duHVBLDo9qRYTeMEqGzTF8SaTLlLZAlAkkCT8etgn3NjQYxN60o/qtkyyDrc5jCMQ+5NoRJfQc6s/HCRbo7oVDMpo/bRaQwb8/RJB9PSgYEgRpFgFTp/CgAhj05hwNIRBg9uhkyQCdgmThl9noqlEANkkgUZB2SrrEgZTh4ZCkCBSKFcysltEDEInT0mLyQ08cmSII0cirbvUVDNzS7LR63RU7kzcips2PY2eHh+u/gAHD7qAiBVDaVkOFouBxgP9jC9MYU8CcgXg8ymkOu1s29qNpIPCCfFTiQDnLSzgne1tsa81pFBbG3kNVpuBZ/6+kkWLx9HS0sKBAwcoKyuLIVcvv/wyX/ziF3n22WdPO7kCuO2229i9e7dKrpI4vUgSrDGMUCjEe++9hyzLTJ06ld7eYwZ/XV1d1NTUMGnSpJjcwKiYenBwkEWLFsUIPD+ImD1Kroa3BKPi+mAwyHnnnRdTLfswkCQJp9OJ0+lk2rRpeDweurq6aG1tpb6+ntTUVFUk/5+e61SiqamJxsZG5s6dG0Nuz1XodDouvW4Sl143CYC6ym6ee7SOd99oZ9AdwKDXkWozISkghhEOfVCnSbwskgGQ8EvQLoKgFxhlMAQlHBo/iQbjMKI2DCaNiBuANCI2EiOrYUZ0BGwKZq+EDh3KEAwMwQACv0NCsYIjJJMRPkaQsjASFkJTtN7r9pMixRO8DAwJ9wkFFDS8UwHoJ0x+XAQPZOqMJHBqoCjdwT67gsNhYs/uxLmBFouewwcHaGkZwmjUMWduNikpEcF5W2ukBzptehrd3T4GXLGVloBfpvpoVE15RS5ud4iKBfl0d3k1pw8Xn1/AtrcjxEkocKQ5wJHmyDEjrUQLqWlW3t2e+HfKYtHz56eWs2jxOFpbW9m3bx9lZWUxN3z/+te/+OxnP8tf/vIXrrvuuoTHOlW4/fbb1azD4TddeXl5qt52+Po7OztjYsuSOPFItgjHMGRZpqGhgcmTJ9PV1UVTUxMLFy7k0KFD6gV8+Bcwml1oNBopLS2NqQC9n5jdYDBw2WWXqd5bI8mV1+uluroaq9X6ofLyPij8fj/d3d10dXXR39+Pw+FQyZbdbj8j221CCPbt20dHRwelpaUxd9JjFR1HBnn20Xq2v9pGa+MQCEGK2YRRltAFdMgoyAhMI6cSnSAGRxxMgYAuhFXocQojzqOaLIFANoBBI/w5UXuyXwqQrlH16pJ85Ih4Mj98klHRy9jSwIFCul+ilxB5H9Ck1G0Dh0aSTCKhPYwutk8UTO2SwvxzaoS8ZGZaaW93x2X/5Rc4kCRUIjUSkyalMmVaGv29fqqrOxO6wZeV57K7tptQ6FjlKifHxuSpafj9YfbW91JWnquSq0QoK8+iqrJHbSWaTUaONPvUVqLZrOfJvy7nkksn0t7eTn19PaWlpaqmCeCNN97gpptu4o9//CM33XTTqOc72RBC8PWvf521a9eyadOmuDieqMj9mWee4SMf+QgAe/fuZcaMGUkN1klGkmCNcUQrSV1dXezbtw+n00lfX19cKby/v5+qqqo4N3d4fzF7Wloa5513HuFwWBWzD3dmj2qJ8vPzY6wfThVCoRDd3d10d3fT09OD2WxWyVZqauoZQbaimY5ut5uysrKkB5gGvJ4Qj//mPTauO0T3YRnCAofZiNVsQAwJpGGaJwWBjIJxBPEaXvHSG0AJKdiFHgWh6RA/aA3h9L2/SWkUAbOCWcOdHbSNVhVk9FmCNAlSfSImumc064dENg6yEAgJDBp9x9ECprVMSqO4O9xCaFiJK7/AwcSJqXjcQQYG/QSDCh3t2tmDAMUzMmhrdTM0FCQjw8K06fGO8OXludSOIFcjccFF4/F6QphMOhoPuDRNSRctLmD7tngCFp1KzMi08rkvzGLV9XPp7++nrq6OkpKSGMPet956ixtvvJGHHnqIT3/60wnXc6rwta99jaeffpr169fHeF+lpqaqlfmvfvWr/POf/+TJJ5/E6XTy9a9/HYC33377tKx5rCBJsMY4ogSrvb2dmpoanE5nXG5gIjd3eH8x+9SpU5k6dapqwxAlVlFy1draSkNDA8XFxWeElkiWZXp7e1WRvE6nU8lWenr6aZnSCwaDVFdXA8RVDpM4hvb2durq6pg9ezY5OTlseP4grzzTSENlL0FvGJOkx2EyggdQItUni0Zkj2QlJtoHIKTI6CVidFsAAYOCORz/mQggY0KnGQqdKHg6ESnrJ0A6ZgQKervAYRek+BVSFX3C2JwjSoDCRBE8pjBpGpmJowVM99oFmQmMUh8Ld9Km0UMtLExBp9eRlWVFp4N9e/vjsv9mzMygpcWNeyh+/6gjfHaOlYb6XlpbtCtgEG/FIEkwbXo6Wdk2ujo9HGx0sXDROLZvGy3cWcfd95Qzc7ZBncSLTipHv/vbtm3j+uuv5/777+fzn/98wmOdSiS6AXziiSf47Gc/CxwzGn3mmWdijEaTLcKTiyTBGuOI9uZ37txJOBzmsssuUwXn0ZbUkSNHKC0tjXFz/zBidp1OFyeUb2lpoaSkJKb8fqZAURT6+/vVVqIsyzETicPzFU8WvF4vVVVVOBwO5syZc0rOeTYiOnU6stoQxc6tHTz/WB3VWzsZ6gli1OlItZnR6yTEQOxPYKKsRDdBHJgQQmC26hE+mTTFSEBSVNPRmOPYFSwejdicBERq0BTCGdQwPEUgdKBXYtcjTDKWTEj1y2SEdOiGrdcjZOwJxO5N+JmoIc5XhCAsgUmDFLYoAcYnIGzr5T4qRWyFauKkSAVreBVJr5eYMTMTp9NEy5EhUlJMNDUP4nFrV74hormq2dVNOKxEbBxy7PT0+Ni/75jFg5bP1UgsWVpIMCDj84Wpr4s3JTUYdPz+T1dzzfKpqv50/PjxBAIB/vCHP/Diiy8yd+5ctm/fzj333MM3vvGNUc+XRBKQJFhjHs3NzdTU1FBYWEhTU5M6CRMOh9m1axcejycu/Pl4xOyXXnoper1e05k9HA6ze/duPB4PpaWlMU7xZyqEEAwODqqxPX6/n8zMTJVsnYyq0sDAANXV1eTl5Z2W1unZACEEBw8eVG8Cjmfq9PB+F888tIedmzvoPOTBbNVjkfSYwjrEUdslLXG80AskBRhmEYEAvwhix4ATY4yXlt8uY9EIpB4gQKqGo3wYBZ0koRMagnYpQKaGpksNtzYoWJwCu6SQHgATuoQRPKNVt/oMsSL7KBJpsACacgRb7G4O7HcBMGVqGq5+P3192h5WALPmZBH0h8nOsTEwEKChvhdlRPevfH4eNdVdhMPxbcHsbBtTpqaSkmLm3/8+EmfjMBzDRe8QmXicMTMTgzHSShxwBXj491exYuV0uru7qampYe7cuWrWqc/n45FHHuGuu+7C4XAQCAS4/PLLWb58OatWrRoTgyZJfDgkCdYYhhCCd999l4KCApxOJ5s2beKqq65Sxexms5nS0tIYZ/D3E7PrdDquuOIKFEXRJFd+v5+qqipMJhPz5s07q1zHh8PtdquVraGhIdLS0tRW4omIqenu7lYDsydOnHgCVnzuIZqXGbX0GH4TcLwY7Pfz9MN1vPXKEZrqByAMKVYjFkmPEhboAiNyDjWIF0SqXhYM6PRgMkgYfJAqjIQRmgHTskmg1wi2TmQJ0aPzk6XEf67CUiSTcXi1TUHBlCowWxSyPAL7iPMPiTApCchSqyHEuLD2d9IvKVg0JiebRIDH5S5yc23MnpuNeyhIdVVnQhuFOXOzaTzQj88XVh9LSzdTVJRBWBbsre9h5qwsqqu0yVUU0cqVxRIhTGaLnoMH+unu9sVtkwhGo47H/nQ111wbmaLetWsXs2fPjsnoq62t5ZprruH73/8+3/nOd9izZw8vvvgiL730EnfeeScrVqxIePwkxjaSBGuMI2r0GQqF2LhxIxUVFdTU1JCfn8+MGTM+kJg9NTWVhQsXqpOCI8Xs0YpMdnZ23LHPZvj9frWy5XK5SElJUb22PsxFv6Wlhb179zJnzpxkGGsCKIrCnj17GBwcpLy8/ITYbASDMi8+tZ9/PX+Qg7X9BL0ydpsRC3qEh4gNBIKgRlYiNgHeES08oRBCximMMbotSBwwrVakRsAnhbEmCHEekIKkarQoI61IM1jD2GyC1DBqQHSiitRo1a1OXYhcRSNOSCjcI7dSPDOD1paIWN1uN1I8IwO9Xsf+/X24+iPaq3kl2ezb24/fH447ThQLFxXg84Ww2owcPjRAZ0e8QD4RcRquvbJY9Ly5sTnheXQ6id8+fAUf+egM+vr6qK6ujjM2rq+vZ9myZXzjG9/gxz/+ccJjJZGEFpIEa4wjOtmnKAqvvvoqOp1OjVEYju7ubiorKxOK2SdNmkRRUZF6vJHO7B0dHdTV1TF16tQ4ofy5hGAwqFa2+vr6sFgsamXL6XSO+rqFEDQ2NqrtruGRREkcgyzL7Nq1i2AwSFlZWcxAxomCEIKtr7bwwh8aqK/swd0bxKTXk2o1IYVB9ok4d3cty4YwChIgCQmbTY8uKHAEDXC0sqXlHG+QpBin+igGCeHUqJ4lsn4IGRSMIwT4ijES3aMXYQp8evQjPo9DQiYlgXZrNBuHf07xs7vVhccTf/Ol00kUz8hg3DgHhw4O0Njo0jwGRJzVK3d2IMvHfmemTE0jN/eY9mpky08LUQKWm2dn8uTUOO2VTifxwG8v52M3zVQnpGfMmEFBQYF6jP3797Ns2TK++MUvctddd416viSS0EKSYI1xRKf7GhoaaGpqYu7cuTFu7scjZq+oqCAzMzOhmD2aPD9nzpwxpVcIh8PqRGJPTw96vV6tbI2cSBzuqF9eXn5W6NJOB0KhEFVVVUiSFNe+PpnYV9vL3363h+p/d9LX5sNq1WPVGdEHUXVbQWQMxIrNAYRDQRoepHw0lFoHpAtTXAZiwKlgHoyvbnVJfnI0qlteUxibxlQgxPprDUe35CdbZ8KcKrDrFNL9YD5aYUtU3RpN6L5W1091MPGUX3lFLrU1EZuFwsIUxhWmMDhCe3Xewnx2vNeBoiS+JC25uJBAIEwgINNQ34vfH6+9Ov/8cbytUd2y2QwUz8jEZNJz0ydmcvMnZ+NyuaisrKS4uDjmd+/gwYMsW7aMT37yk9x7773n7A1hEicXSYI1xhHVW/l8PgKBAAsWLFD9r45HzH7JJZdgNBo1ndllWaaurg6Xy0VpaWlMOOpYg6IoaiB1d3c3iqKogdROp5M9e/YQCoVOWkXmXEAgEKCyslI1oz1dE5U9HV6efngPWzccobXRjRTVbaEnJCsYRvhcyQgEIi7/MFrxkoVCmtOENKTglI0MEiJNw1HdqwtjU7SJlB8Zi4bWKxEpC5kExmEaMHE0usdhFSj+EIVK/PlHm0xszFHYnR+O8a6KYv6CvIR6qtS0iPbK6TTz3rttDA5q5wZCvFjdao1or0wmPQcO9NPb40tIrqKQJPjf+y/lk7fMUYPqp0+fHmMR09zczJVXXskNN9zA/fffnyRXSXxoJAnWGEdNTQ1DQ0OUlJTw9ttvM3fuXDIyMv5jMXsgEGDXrl0AlJSUJEnDMAghGBgYoKuri87OTvx+PyaTialTp5Kbm3vWCv9PJrxeL5WVlaSlpcUZ3Z5O+Hwh1j6xl389d5DmvYMoIUFqihlDWEIZEkhHf129hLBpVJIUi4zOf4y0KEIBIbCiI1PEh1L7LQoW//FbPySaZITELvRdko8CuxmLTeAIyGTIx/ZPNJl4WPh5Qu7GbNYzY2YmFouBg439TJ6S9r5VqYWLCnj3nbZI0PLMTGw2I4cPD8SYk76fWF2S4JLLJuLzhuk86nultc19/3sJn/7sXJVcRSULUbS2tnLllVdy9dVX89BDDyXJVRL/EZIEa4wjGAyiKAqSJPHvf/+b4uJirFbrqGL2lJQUFi9ejCzLyLIcR66Ghoaorq5WL4ZJ7yZtRMO009LSsNvt9PT04Ha7SU9PV1uJJ2Ii8WxH9H060+0qhBBsXHeYNY/vZX9tL57+MBa9HqfVhOQFnwhjHVGBChDGpKHFGiKIQxgRkiArxYzBBRb0CUXwbmMYRyie+MgIFESMwD6KRKQsZBEY/cOqW3oZWzrYFQVfIMREDUf34FGh+/Aa1aLFBfT1+cjMjJh9ammvFp1fwPYEeqqo75XVpueN1xOL1SG+LZifb2fipFS83hD1dT2EQoJ7f7WUz35uHkNDQ+zYsYMpU6bETOi2t7ezbNkyLr74Yn7/+9+fMSQ+ibMXSYI1xhGd+APYtm0bGRkZHD58OKGYfeLEiRQXFycUs0ftBSZNmsTkyZPP2Ivh6UZvby81NTVMnDgx5n3y+XzqROLAwABOp1NtJY5FXVZ/fz/V1dVMmjSJSZMmnVWfp9r3unj6oT1Uv9XJUG8Qm8WAw2xE8oHiP/b90vTcQiD0Ap2siz6AjIxeHNVtaWwf1CmYlfibmV7JT6ZWbE8CrRckbjm6jAHyU01YpTCpPrAOI24PhzvoJHJTplVxysu3M2lSKh5PhPQsOK/gfQ1Cz79gHG9vbT3qe5WGPxCmoa6HQOAYlXu/tqAjxcTdv1jCTZ+YxdDQEDt37lS/d1F0dnZy9dVXs2jRIh5//PEkuUrihCBJsMY4hocvb9myBZ8vPr8rivLycrKyshKK2Zubm2lsbGTWrFnJCIZR0NbWRn19PTNnzoyZWhqJYDCoarZ6e3ux2WzqRGJKSspZRTY+DKJkvaio6IyIUfpP0N7s5q+/3c2/XzlCT5sXnSzhtJkwCz2KV9G0fkjkuTVEELswYNBBttmCyRPxwUpUkXJbwzh88dWtEAp6pDhRPoxS3TILjEe9wQQKeocgxSZw+BW2hAbYITzvS3gALloyHq83jE4nsbehV1N7tfiCcWzbGn+cqPbKaNRjsejYsrll1HPd/YslfOHLpbjdbnbs2MGECROYMmWK+nxPTw/XXHMN8+bN46mnnkpW3JM4YUgSrDEORVEIBALvK2ZfunQpJpNJU8yuKAoNDQ10d3dTWloaExKdxDEIITh8+DCHDx9m3rx5mpEuiRAOh+np6VEnEo1Go1rZSktLO+fuuKO5gueiF5hnKMjzf2zgX88dpPXAEJIicNhNWIQeZUgwLDdZNTAdDkWnICnHzEUVoSAhMCgSuRG709jtJYEi4kX2AP1SgHQNY1O/U8GSoLqlrd0S9GYE0S0x03jAReMBV8LXP7K6ZTDoKJ6RgdNporl5kNYW93GRtMXnj+Od7W0UFWeQnm6hrW2IpsODMdv8zy+W8MUvl+LxeNixYwfjx49n6tSp6vN9fX0sX76cadOm8eyzz6o3jEkkcSKQJFhjHH6/n7fffntUMfvll1+OEEJTzB4KhaipqSEUClFaWprUDCVAlIT29PRQVlb2H01UKopCb2+v6rcFqGQrIyPjrL8Df79cwXMJsqzwynON/OPP+9lf20fAE8ZqNOA0m8ALQVlGjy7Oc8uvD2OR48mARwSxosem15OJGX0osp/LGCQtpDEZaJexa4jgRwurHq26tYYmkCLtwImTUvF6QjTURzRQENFlbd82uofV0ksnEPTL9Pb52NvQp7lNItH7uHEOCic6cQ8F+fjNs/jil0vxer3s2LGD/Px8pk2bplZ+BwYGWL58OePHj+eFF15IDpckccKRJFhjHAcOHGDPnj2azzkcDi688EJCoZCmmN3j8VBdXY3dbmfOnDnJu78ECIfD1NbW4vP5KC8vP6EkVAiBy+VSdVuhUCgmI/FsumgMzxUsKysbk5XQdze38sIfGqja0olvIIzJoCPVaUYaEohhXTQZBQFxVamAPow5SryO6raMSBiFRK6GGWlQUjAI7TahSwpqhlh77GHsHu3v+kumFjy6WJsGR4qJmbMySEuz8M620a0YRhKwzCwrU6elEQoq1Nf34PfJxxXuHG0L+nw+duzYQW5uLtOnT1fJ1dDQECtXriQjI4O1a9cmp5yTOClIEqwxjsOHD6t2CsNRWFjIzJkzE4rZ+/r62LVrF+PHj4+5K0wiFoFAgKqqKgwGAyUlJSeV8AghcLvdKtnyeDxkZGSoE4ln8kXkROQKnms4vM/F3363m23/aqWvy49egVS7OeLO7k9s/SCbFfSB+PaeX4SwoCdNZyQlbFCrU16rjE3Dod2bImMbin88kQAe4F1DD4cMsYajFouembOyqKrsxGDQMWNmBg6HieamQdraItvqdDB/QT7vvpNYpmCx6LngwvG43UEOHHDR26OtF737nov5wpdKVHKVnZ1NcXGx+hvl8Xi4/vrrsVgsvPTSS8mqexInDUmCNcbR2trKjh07Yh4rLS0lJydHzSkcLmaHY1l5M2bMiHE/TiIWHo+HqqoqUlNTmT179inXSXm9XpVsDQ4O4nQ6VZG8zWY7pWsZDScjV/Bcg6vXz3OP1fHaC410HPKCIuGwGLFbDSj9sbqtIDJGjfaeWwriOFqRiuq2bCLSfNSyfvASxqbhkwWJ8w87bH42Kx3qv51OE+MLndTt6dE8zqTJqRQUOLBY9LwxSm6gJEWc3t/Z3q7+e3pRBllZVtrb3Rw6OIAkwf+792I+94US/H4/O3bsIDMzkxkzZsRM6d54440AvPzyy2fU9yCJcw9JgjXG0dnZyfbt29V/Z2RkMH/+fJVc6fV6VdMjhGDfvn20t7dTUlKSzMobBS6Xi+rqasaNG3dGVPgCgUBMRqLdblfJlsPhOG3rG54rWF5ejskUf9FOIoL29vaj06dz2L6hj5f+eoB9u/oIhxTsRgMpZjN4BCiJJxCFSSAFY//WiiKQJRmb0JOJCZM4Vp0K2hVMnvgbg9GqW3vnesnMtjAw5MftDnP40EDC12Sx6ikqyqRmV1dCKwadDirm5/Peu4mrW+PGp/D9HyziozfNJBAIsGPHDtLT05k5c6b62fb7/Xz84x/H5/OxYcOGZJU0iZOOJMEa46ipqeHQoUNIksSMGTPo6upi7ty5cXqr4Tqi0tLS5J3fKOjs7GTPnj1Mnz6dwsLC072cOIRCIXUisbe3F5PJFDOReKrIVjRXUKfTUVpamtTwjYLW1lb27t0bJ/yPhlKv+/M+qrZ04B8KY9LpcFrN6AUIT+xxErUVBwnixKTqtkxIpCpG/JKsbWyaIOMQ4A1jO2nTbbjdQQxGHYUTnQwMRnIHh4c4O50mCsal0FDfG3cMmy1ixWAw6NDrpVHDnXU6if+9/1I+8anZBAIBdu7cidPpZPbs2epnORgM8olPfILe3l5ee+01nE5nwuMlkcSJQpJgJcHu3buZPn06LS0tHDhwgKKiIjIzM9ULns/no7q6GpPJxLx5884q4fSpRlNTE42NjcydO/esCLaWZTkmI1GSJLKzs8nOziYzM/OktTX9fj9VVVWnPVfwbMCRI0fYv38/ZWVl71s13lvTy/O/r+fdN9rpbfWikyTSbGaMYUkNpdYkWRIInUCSY8l1WJHRS+AUBtKEKabtGLIJjN54Mt43Lsw7vi48ntgkiNQ0M9OLM5AVhe4eHxJw+PD7V7d213ZTPCODtHQLrUeGaG4+ZsWg10s88NvL+ejHZxIMBtm5cycOh4M5c+ao5CoUCvHpT3+alpYWXn/99WTlPYlThiTBSgK/308oFCIQCHDo0CF6enoQQpCdnY3D4eDQoUPk5uZSXFx8zvktnSgMb5+erRNwiqKoE4nd3d2EQiGysrLUicQTVWGK5gpGWzjJz1RiNDU1cfDgQcrKykhLS/tA+/Z2efnrb3ez7dVWWvYNISngsBqx6PUoPoEuHEuORjM2TcGEIJKTaBN60oWJfimoadcwIAV5zZS4nTdlahp+f5jMbCtWq4GDh1x0dnpjtnE6TYwbn0J9XXx1q3CCk3HjUxgaCvCNby1gxcrphEIhduzYoU40D6+8f/7zn2ffvn288cYb57ztRxJnFpIEa4xjcHCQvr4+1axSp9MhSRIul4tDhw7R29uLTqcjNzeXnJwcMjMzk9WGEZBlmd27d+N2uykrKzsn2qdCCIaGhlSRvNfrJTMzU20lflit1NmSK3gm4NChQzQ1NVFeXv4ft7T8vhBrHm/gjXXNNNb2E/Ip2MwG7EYDwg2SOBq3o+EojxFESMRUr4QQyELGip4MYYrbp6UkyK7mbnzeWMuGeaU5NB7ox+OOrW5Nm55OVo6Vzi4Pg4MB7A4Thw6OUt2y6Pnjk9dy+RWTCIVC7Ny5U62GRsmVLMt85Stfobq6mjfffJOcnJwP89Z9KGzZsoVf/epX7Ny5k/b2dtauXcuqVavU5z/72c/y5z//OWafq666ig0bNpyyNSZx8pEkWGMcf//73/nkJz/JkiVLWLVqFddddx2ZmZl873vfIzs7m89//vOYTCY6Ozvp6uoiGAySlZVFbm4uWVlZY55sBYNBdu3ahRCC0tLSc1ak7fF41MrW4OAgqampqkj+eKf+zuZcwVOJ4X5gFRUV/5EpbaLjb1x3mHV/2UvDzl58A2HM0VDqMJHq1sgJxASaqyGCpAgTkkGgCwtSFSMOjOzXD7LfMUTxzExMFj0HD7iYWpTOe9vbYnRYIzFxUipWqx5nmgWPJ0hdfQ/hcOz2KSkm/vy35Zx/wXjC4TA7d+7EZDJRUlISky5x2223sX37djZv3nzKo7teeeUVtm7dSkVFBTfccIMmwers7OSJJ55QHzObzcn25TmGJMEa44j+mK9evZo1a9awY8cOUlNTCYVCPPHEEyxbtky9EA6vanR2duL3+9UWUnZ29pgTKft8PiorK1XNx1ghm36/X51I7O/vx+FwqJWtRBOJ51Ku4MmEEIIDBw7Q1tZGRUXFKZl0q323k+ceradmWxf97X6MJh0OoxF9UIJAZBs5Ej8dH7djFhCI/XvLQkZBocbQDxLY7QZmzM5iaDBIeqaFtla3pvZqzrwsmg8PxhiRpqSYKJqZgQAaGnowWww8/dxK5pXkEA6HqaysxGAwUFpaqpIrIQTf/OY3efPNN9m8efNpt5KRJEmTYLlcLtatW3fa1pXEyUeSYCWhoq2tjWuvvRaXy0V2djZVVVUsWLCAFStWsGrVKgoLC2PIlsfjUStbHo+HzMxMcnNzyc7OPueF8AMDA1RXV6vatLFajQmFQnR3d9Pd3U1PTw9ms1mtbKWmpiJJ0jmdK3giEdXxdXZ2UlFRgd1uP+VraG9287ff7mb7xlbaD7sjodRWI2YMhMMyuqAU56+VSLt1UDdA5gwrPp9M65HYKK5xhSmML0zBNeBnb30f8xfms/O9DsJhJeHaphWl8+Qzy5k8OQ1ZlqmsrFQnUIdbyXz3u9/ln//8J1u2bGHChAkn4F35z5CIYK1btw6TyUR6ejqXXnopd999d1Ijdo4hSbCSAGDPnj1cffXVLF26lD/84Q+YTCba2tpYu3Yta9as4a233qKkpIRVq1axcuVKpkyZEkMqoi2kzs5O3G636iD+n+h1zlREqzFTp05lwoQJY5ZcjYQsy/T29qqtRJ1Oh9VqZWhoiHnz5p0VU5WnC0IINaty/vz5Z4TZqmcowPN/aGDjmsO07B9CyAKbxYBF0aN4IrotgBAKejTiduwKe+jDH0hMmkxmHRUL8gmFZMJhQV19T5xuC6B8fh5PPr2czCwrsixTVVUFQFlZWQy5+tGPfsTq1avZvHkzU6ZMOTFvxH8ILYL17LPPYrPZmDx5Mo2Njfzwhz/E4XCwbdu2MVMJHwtIEqwkAOjo6ODvf/87X//61+MIgxCCrq4u1q1bx5o1a3jzzTeZOXOmSrZGVnB8Pp9a2RocHCQtLU2tbJ3tsRRRF/vZs2efcl3H2QRZlqmrq6Orqwu9Xo8QQm0nD7cASSLy/aqrq6O/v5+KioozglyNhBCCfz57gPV/3k/jnn58g2Esej2p1kgotU+EsSrxf9M2s4ecGRZkKUxTk5uhIVl9rnCiE6NRx8EDLvUxs0VP8cwMTBYDjfv76enxsfKG6fzmd5djsRiQZZnq6moURaGsrCzmc/Tzn/+cp556is2bNzN9+vST+n58EGgRrJE4ePAgU6dO5fXXX+eyyy47dYtL4qQiSbCS+EAQQtDf38/69etZvXo1r7/+OlOnTmXlypWsWrWKWbNmxYzd+/1+tbI1MDDwocTRZwKEEDQ2NnLkyBFKS0uTYtRREK3GdHd3U15ejt1uZ3BwUJ1I9Pv9MRmJ51qF84MgGhM0NDR0woPATyZ2vNXGc4/WU/t2F+7+EHabAZvRgOQFETi2XQCZA7oBkCKGoJOmpWC2C0JKgH0NPoLBxJcfo1HHT39xIZ/5/Dwg8l7t2rWLUChEeXl5DLm69957eeyxx9i0aRMzZ848aa/7w+B4CBZAdnY2d999N1/+8pdPzcKSOOlIEqwk/iMMDAzw4osvsnr1av71r38xfvx4lWwNn+qBSFxL9CLb399PSkqKav9wJlsbKIqiVhjKysqSERujQFEUdu/erRIGLRLtdrtVkfzQ0BBpaWkq6T5bCMaJgKIo1NbW4vV6qaioOGuJZtOBAf72291s3XCE/q4AekXCaTNhFnqEV9Al+ejWRYKZ51XkMNDnp+nQIAWFdtKzDfT0eWlu8g2PUyQ3386Dj13B4gsjAxGKolBTU0MgEKC8vDxG4/nrX/+a//u//2PTpk3MmTPnVL7048LxEKyWlhYmTJjAunXrWLFixalbXBInFUmClcQJw9DQEP/85z9ZvXo1r7zyCllZWaxYsYLrr7+e+fPnx5CtYDCoXmR7e3ux2+0q2TqTCEwoFKKmpoZQKERZWRlms/l0L+mMxYfJFYxWOLu6unC5XDgcjpiMxHMV0WpMlDCcreRqJAb7/Tz7WD2vrz5E+0E3OgVSU8w4p1iQ7PDu2+1oXXDSM83kT7Dg9gZIz5b4yjemMWVqAdnZ2VitVnbv3o3P56OioiKGXP32t7/lvvvuY+PGjZSVlZ26F/o+cLvdHDhwAIjoxH7zm99wySWXkJGRQUZGBj//+c/5yEc+Ql5eHo2NjXzve99jaGiI2tra5G/MOYQkwUripMDr9bJhwwbWrFnDSy+9hNPp5LrrrmPVqlUsWrQoRsgZzcbr7Oykt7cXq9VKTk4Oubm5pzWIOBrnYjabmTdvXlI3NApORK5gMBiMyUi0WCwq2XI6nefMMEGUiIbDYcrKys7ZidtQSOYfT+3n5b8doLG2H3cwiDPHwoRpTry+EPV1vQSDxzRZs+Zl8b27FlGxKFv9HPT19SFJEjqdjlmzZpGdna1+Dh577DF+/vOf89prr7FgwYLT9TI1sWnTJi655JK4xz/zmc/wyCOPsGrVKqqqqnC5XBQUFHDllVfyP//zP8kp23MMSYKVxEmH3+/ntddeY82aNaxfvx6z2cx1113H9ddfzwUXXBBzMQ6Hw+qPa3d3N2azWa1sncqL7NDQEFVVVWRmZibjXN4HJyNXUJZl9XPQ09ODXq9XNVvp6eln7d8jOgEnhIgTaZ/rePu1I+zY2sGOt9uor+nDYNRRfn4uWQVWrrhuChdeGhuMLoSgpqaGgYEB0tPT6e3t5c4772TixImkp6ezbt06Xn31VRYvXnyaXlESSYyOJMFK4pQiGAzy5ptvsnr1atatW4cQguXLl7Nq1SouvvjimFZJdOy/s7OTnp4eDAaDWtmKeiydDPT29lJTU8PEiROZPHnyOVM5ORnwer3s3LmTjIyMk0ZEFUWhv79fbSUqiqIam55N0U3hcDimyne2rPtkIRxWMBi0Py/RycqBgQEqKiowm80oisLrr7/Or371K7Zt24bRaOTKK69kxYoVXHfddcmp3iTOOCQJVhKnDeFwmLfeeovnn3+edevW4fP5WL58OStWrOCyyy6LETwriqJ6LEVH/6Pto/T09BNGgtra2qivr2fmzJkUFBSckGOeq4jmCubn5zN9+vRTQkSFEAwMDKifg0AgQFZWFtnZ2We0wW0oFKKyshKj0UhJScmYJ1ejQQhBfX29alsx/Hfg73//O7fffjv/+Mc/KCgoYP369axfv56qqiq6urpOeKxQEkn8J0gSrCTOCMiyzNtvv80LL7zAunXrcLlcLFu2jFWrVnHFFVfETBlGKxpRry1ArWx92PaREILDhw9z+PBh5s2bl3RUfh8MzxWcPHnyaVlDNE0gSrbcbjfp6elqK/FMmUgMBoNUVlZiNpvjJmuTiEXU4qO3t5f58+fH/A3Xrl3Ll770JdasWcNVV10Vs5/L5SItLe0UrzaJJEZHkmAlccZBURTeffddXnjhBdauXUtnZydXXnklq1atYtmyZTHTZVFfruhFVpZltbKVmZl5XBczRVFifJuSd8Gj40zNFfT5fOrnYGBgAKfTqbYST0fsDESsSSorK7HZbMydOzdJrkZBNCqoq6srzs3+pZde4tZbb+W5555j+fLlp3GVSSRx/EgSrCTOaCiKQlVVFS+88AJr1qzhyJEjXHbZZaxatYprrrkmRvgebR9FK1vhcFh1D8/KytJsy8iyTE1NDT6fj7KysrPK/PR0INpCPdNzBUfagNhsNpV4p6SknJJ2pt/vp7KykpSUFGbPnp0kV6NACMH+/fvp6Ohg/vz5MRXrDRs2cMstt/DUU09xww03nMZVJpHEB0OSYCVx1kAIwe7du1WytW/fPi699FJWrlzJ8uXLY7RYQgjVPbyzs1PV6uTm5pKVlYXBYCAQCFBdXY1er6ekpOSM1e+cKWhububAgQOUlJScVS3U4ZOpPT09GI1GtbKVlpZ2UoiPz+dj586dpKenM2vWrOSgxCiIpiS0trayYMGCGHK1ceNGbrrpJh5//HE+/vGPn8ZVJpHEB0eSYCVxVkIIwd69e1WytXv3bpYsWcLKlSu57rrrYvxyhBC43W6VbPl8PtLS0hgaGiI9PT3ZunkfRC+ALS0tlJWVkZqaerqX9KGhKAp9fX2qDYgQQiVbGRkZJ0R87vP52LFjB1lZWcyYMSNJrt4H0c/W/PnzY1q5b731FjfeeCMPP/wwt9xyy2lcYRJJfDgkCVYSZz2iBGD16tWsWbOGyspKzj//fFauXMmKFSvIz8+PucgdOXKEffv2YTAYCIVCZGRkqGHU54qj9onCyFzBc8ldXQiBy+VSyVYwGCQzM1NtKX+YiqbH42Hnzp3k5uZSVFSUJFfvg0OHDtHU1MT8+fNjPlvbtm3j+uuv5/777+fzn//8aVxhEkl8eCQJVhLnFIQQNDc3s3r1atauXcv27dtZsGABK1euZOXKlbzxxhvcd999vPTSS0ydOhWv16tWtqIVrahWZ6xHVhxPruC5guFVzq6uLjweT0wg9fF8FtxuNzt37qSgoIBp06YlydX7IDq1W1FRETNY8t5777FixQruvfdevvrVr57GFSaRxH+GJMFK4pyFEIK2tjbWrFnDmjVr2LJlC0IIbrjhBn72s5/FmYiOnEJLTU1VXeTPlJH/U4UPkyt4LiFKvLu7u9WJxCjx1gomHxoaYufOnRQWFjJlypQkuXofNDU1cfDgQSoqKnA6nerjVVVVLF++nJ/97Gd84xvfOI0rTCKJ/xxJgpXEOQ9FUbjjjjt46qmn+NznPkd1dTWbNm1i1qxZrFq1ipUrV8a1cwKBgFrZcrlc6gU2Nzf3nK7kwInJFTyXEAgE1InEvr4+7HZ7TCD14OAgVVVVqvN/EqPjyJEjHDhwgPLy8hg9X01NDddeey3f//73+e53v3saV5hEEicGSYKVxDmPz372s7z99tu88sorTJ06FSEEfX19rF+/ntWrV/P6668zffp0Vq5cyapVq+IiX4LBoFrZ6uvrw+FwqJWt0+WvdLIQtRaI+jYlHcdjEQ0m7+7uVjMSQ6EQ48aNSwrajwMtLS3s37+fsrKyGGPQuro6rr76ar75zW/yox/96PQtMIkkTiCSBCuJcx6bNm1izpw5ZGVlxT0X9c568cUXWb16Na+++iqFhYWsWLGC66+/nnnz5sWQrVAoRHd3N52dnfT19an+Srm5udjt9rP6AuvxeKisrDypuYLnEnp7e6muriYlJQWv14skSWpkz/Ga3I4ltLa2snfvXsrKykhPT1cf37dvH8uWLeNLX/oSd91112lcYRJJnFgkCVYSSQzD0NAQL7/8MqtXr2bDhg1kZ2erZKuioiLmohkOh9XWUU9PDxaLRSVbp8rM8kQh2uY6lbmCZzN6e3vZtWsXxcXFjBs3DkVRcLlc6uchFArFmNyO9TZre3s79fX1lJaWkpGRoT7e2NjIsmXLuOWWW7jnnnuSn7skzikkCVYSSSSAx+Nhw4YNrFmzhpdffhmn08mKFStYtWoVCxcujGmfybKsmll2d3djNBrVNmJqauoZfeGI5gpOnjyZSZMmne7lnPGIRgXNnDmT/Pz8uOeFEAwNDaltZa/XS2Zmpuq3NdYGBjo6Oqirq4szqG1qauLKK6/kxhtv5De/+c0Z/R1JIokPg2QN+wzGli1buO666ygoKECSJNatWxfzvBCCn/70p+Tn52O1Wrn88svZv39/zDZ9fX188pOfxOl0kpaWxuc//3ncbnfMNjU1NVx00UVYLBYKCwv55S9/GbeW559/nhkzZmCxWJg7dy7//Oc/T/jrPdNgt9v5yEc+wt/+9jfa29v53e9+h9vt5mMf+xjFxcV861vfYsuWLYTDYfR6Pbm5ucydO5eLL76YGTNmEAwGqaqq4q233qKhoYH+/n7OtPuZ7u5uqqqqmD59epJcHQe6urqoqalh9uzZmuQKQJIknE4n06ZN4/zzz2fx4sWkp6fT1tbGli1beO+992hqasLn853i1Z96dHZ2UldXFxeg3tLSwjXXXMOKFSuS5ArOuN+FJE4MkhWsMxivvPIKW7dupaKightuuIG1a9eyatUq9fn77ruPe+65hz//+c9MnjyZn/zkJ9TW1lJXV6faClx99dW0t7fz2GOPEQqFuPXWW1mwYAFPP/00EGkNFRUVcfnll/ODH/yA2tpaPve5z/HAAw/wpS99CYC3336bJUuWcM8997B8+XKefvpp7rvvPiorK5kzZ84pf19ON4LBIG+88QarV69m3bp1SJLE8uXLWbVqFUuWLImpUAx3Du/q6kKSJHUCLT09/bTqdM6WXMEzBR0dHezZs4e5c+eSk5PzoY7h9/vVNmJ/fz8Oh0OtbDkcjnOKaHR1dVFbW8u8efPIzs5WH29vb+eqq67ikksu4bHHHhvzWjUhhPp3b2lpOaMC1JP4z5AkWGcJJEmKIVhCCAoKCrjjjjv4zne+A8DAwAC5ubk8+eST3HTTTdTX1zNr1izee+895s+fD0SCU6+55hpaWlooKCjgkUce4Uc/+hEdHR0qMfj+97/PunXraGhoAODjH/84Ho+Hl156SV3PokWLKC0t5dFHHz2F78KZh3A4zJYtW3j++edZt24dgUCA5cuXs3LlSi699NIYg8qoTicaRh2NacnNzSUjI+OUXmiamppobGw863IFTxeiGqJ58+ZpDkt8GEQnEqMaPrPZrJLvM72t/H7o7u6mpqYmjox2dnZy9dVXs3jxYv70pz+NeXI1HB/5yEeYOnUqv/zlL1EUJfnenANI/gXPUhw6dIiOjg4uv/xy9bHU1FQWLlzItm3bgEjcRFpamkquAC6//HJ0Oh3vvPOOus3IqstVV13F3r176e/vV7cZfp7oNtHzjGUYDAYuvfRSHnnkEVpaWli3bh1paWl861vfYvLkyXzuc5/jH//4B16vF51Op07oLVmyhJKSEgwGA/X19WzevJndu3fT1dWFLMsnbb1CCA4cOMChQ4eoqKhIkqvjQGtrK/X19ZSUlJwwcgVgNBrJz8+npKSEpUuXUlRURDAYpLq6mi1btlBXV0dPTw+Kopywc54K9PT0UFtby5w5c2LIVU9PD9dddx0VFRX88Y9/TBKIETAYDDz55JO0trYm35tzBMm/4lmKjo4OgLjWTm5urvpcR0dHXCvDYDCQkZERs43WMYafI9E20eeTiECv17NkyRIefPBBDh8+zCuvvMK4ceP40Y9+xOTJk7nllltYvXo1brcbSZJIT0+nuLiYCy+8UHVL37dvH5s3b6ampobOzs4TSraEENTX19PW1saCBQvO6tDmU4UjR46o1gInk4zq9XpycnKYM2cOS5YsUQPI6+rq2Lx5M7W1tXR2dhIOh0/aGk4Eent7qampYebMmTG/GX19faxYsYKZM2fy5z//+ZT6q50ILeupwK233ooQgt///vfIspzUZZ0DSBKsJJI4CdDpdCxevJhf//rX7N+/nzfffJOioiLuvvtuJk2axE033cQzzzzDwMAAEKk+FhUVccEFF7BgwQJsNhuNjY1s2rSJXbt20d7eTigU+tDrURSF2tpa+vv7WbBgwTlnkHoy0NTUpDqOD/dtOtmIVjpnzJjBRRddRHl5ORaLhcbGRjZv3kxVVRWtra0Eg8FTtqbjQV9fH7t27WLGjBkxAwADAwOsXLmSSZMm8fTTT59yywqPx0NJSQkPPfSQ5vO//OUvefDBB3n00Ud55513sNvtXHXVVfj9/pOynpEVyehN1LJlyzjvvPN49tlnURQFSZKSJOssR5JgnaXIy8sDIpqG4ejs7FSfy8vLo6urK+b5cDhMX19fzDZaxxh+jkTbRJ9PYnTodDrmz5/PPffcQ0NDA++88w6lpaXcf//9TJo0iY9+9KM89dRT9PX1AZCSkqJOoC1cuBCHw8Hhw4djLq4fhGyFw2Gqq6vx+XwsWLDgnI/6ORE4dOiQ2kYd7jh+qiFJEqmpqUyfPl39PKSlpdHS0sKWLVvYsWMHzc3Np30i0eVyUV1dTXFxMQUFBerjQ0NDrFq1iry8PJ577jmMRuMpX9vVV1/N3XffzfXXXx/3nBCCBx54gB//+MesXLmSefPm8Ze//IW2tra4SteJQrT919LSAkSql1HSddddd9Ha2srdd98NcFbr8JJIEqyzFpMnTyYvL4+NGzeqjw0ODvLOO++wePFiABYvXozL5WLnzp3qNm+88QaKorBw4UJ1my1btsRcsF977TWKi4vVu/bFixfHnCe6TfQ8SRw/JEli7ty53HXXXdTW1lJdXc3ixYt59NFHmTJlCqtWreLxxx+nu7sbIQQOh4OpU6eyePFiFi9eTFpaGkeOHGHz5s3s3LmTlpaWUSsZwWCQyspKhBBUVFSMOQ+mDwohBI2NjTQ1NcUFEZ8JcDgcTJ48mYULF3LhhReSk5NDV1cXW7duZfv27Rw8eBC3231KKx8DAwNUVVVRVFTEuHHj1Mc9Hg8f+chHcDqdrF69Ombg40zB8WhZTwZuv/12li5dys9//nN6enrU1u+ECRO46KKLePHFF2ltbQWSFg5nM5JThGcw3G43Bw4cAKCsrIzf/OY3XHLJJWRkZDBhwgTuu+8+7r333hibhpqamjibhs7OTh599FHVpmH+/PmqTcPAwADFxcVceeWV3HnnnezevZvPfe5z3H///TE2DRdffDH33nsv1157Lc8++yy/+MUvxqxNw8lA9ML+wgsvsGbNGqqqqrjgggtYuXIlK1asIC8vL+Zu1ufzqWHUg4ODpKWlqRNo0b99NFfQbrczZ86cZK7g+yA6ANDW1kZFRQUOh+N0L+m4EQwG1YnE3t5eNVUgJycHp9N50iohAwMDVFZWMnXqVCZMmKA+7vP5uPHGGwF4+eWXsdlsJ+X8HxQjp7HffvttLrjgAtra2mLamh/72MeQJInnnnvuhJx35FTgH//4R1566SXeeOMN8vLyWLZsmToY895773HBBRdw//33c9ttt52Q8ydxepAkWGcwNm3axCWXXBL3+Gc+8xmefPJJhBD893//N7///e9xuVxceOGFPPzwwxQVFanb9vX1cfvtt/Piiy+i0+n4yEc+woMPPhhz8aipqeG2227jvffeIysri69//evceeedMed8/vnn+fGPf8zhw4eZPn06v/zlL7nmmmtO3osfwxBC0NTUxOrVq1m7di3vvPMO5513HitXrmTlypWMHz8+5oLp9/tVny2Xy4XT6SQ9PZ329nYyMzOTuYLHASEE+/bto7Ozk4qKirNaozY8VSAaSB312jqR3muDg4Ps3LmTKVOmMHHiRPVxv9/Pxz/+cXw+Hxs2bDijiOrpIlhRvPjii1x55ZWYzWb6+vpob2/nZz/7Ge+++y6dnZ18/vOf59JLL+Wll17i3XffZe3atTG/50mcXUgSrCSSOIMhhKC1tZU1a9awZs0atm7dSllZGatWrVKFw8PJViAQoLm5maamJoQQOJ1OtZJxNpOGkwkhBA0NDfT09DB//vxzSqOmKAr9/f0qAVcURSVbmZmZH7qqOTQ0xM6dO5k0aVJMAkAwGOTmm2+mv7+fV1999YxrsY4kWAcPHmTq1KlUVVVRWlqqbnfxxRdTWlrK//3f//1H5xteuVq/fj2f+tSnuPnmm3nwwQfVSjNAfX09zz33HE899RRDQ0MMDAxgs9l45JFHuOmmm5BlOVmBPguRJFhJJHGWQAhBZ2cn69atY/Xq1WzatIk5c+awcuVKVq1axfTp03nllVf4y1/+wj333MO4ceNU1/De3l7sdrsaRn0mVRVOJ4QQ1NXV0d/fT0VFxTlFrkZCCMHAwIBKtgKBAJmZmeTk5JCdnX3cAnS3282OHTuYMGECU6ZMUR8PhUJ8+tOfpqWlhY0bN57W4YBESGTY/J3vfIc77rgDiFTmcnJyVMPmD4vh5GrHjh1UVlZy77334nK5+MQnPsGvfvWruM9bbW0tu3bt4v7776eqqorZs2ezffv25M3RWYokwUoiibMQQgh6e3tZv349q1evZuPGjeTm5tLe3s7XvvY1fvGLX8RUtqKu4Z2dnfT29mK1WmPI1licVlIUhT179jA0NKRaIYwVCCHweDwq2XK73aSnp6tkK9F74fF42LFjB+PHj2fq1Knq4+FwmM997nOqJUlGRsapeinvixOhZf1PcPfdd/PAAw9QUlKC1Wpl9+7dNDc384UvfIFf//rXpKSkEAqFYgiu1+vlwQcf5De/+Q133303X/rSl2IidZI4O5AkWEkkcZZDCMFjjz3GN77xDebMmUNdXR0TJ05kxYoVXH/99appZRThcJje3l46Ozvp6enBZDKRm5t70gXRZxKivmBerzc5XcmxoYmuri4GBgZISUmJay17vV527NhBfn4+06ZNUz8nsizz5S9/mV27drFp06aY3MEzASdCy/ph8a9//Yvly5dz55138rWvfY2CggIGBgb44he/yObNm7nmmmt44IEHSE1NVduA0cpXOBxm0aJFpKamxk1xJ3F2IEmwkkjiLMf999/Pf//3f7Nu3TouvfRSBgcHefnll1m9ejUbNmwgNzdXJVvl5eUxZEuWZXp7e+nq6qK7uxuDwaBWts72PLxEUBSFXbt2EQgEVAf9JI4hGAzGtJZtNhvp6el0dXWRl5dHUVGR+rlQFIXbbruN7du3s3nz5qQ33lFESdKvf/1rfvzjH/Pee+8xZ84ctVLl9Xr58pe/zN/+9jc++9nP8r//+79kZGSo+0WrVT/96U95/PHH2bZtG4WFhaf7ZSXxAXFqLXWTSCKJEwohBM3NzWzcuJEFCxYA4HQ6ufnmm7n55pvxeDy88sorrFmzhuuuu460tDRWrFjBypUrWbhwoRrRkpOTg6IoKtmqrq5GkiSVbKWlpZ0Tk4iyLLNr1y7C4TAVFRWnxfjyTIfJZGLcuHGMGzeOcDhMW1sb+/fvVzWAVVVVOBwOrrjiCr73ve+xdevWJLmCmBZeT08POTk5GAwGAoEAgUAAiORPyrKMzWbj8ccfp7q6mmeeeQafz8eDDz5Idna2epze3l62bNmC3W4/Y2wukvhgSBKsJJI4iyFJEvfff3/C5+12OzfeeCM33ngjPp+P1157jdWrV/Oxj30Mi8XCihUrWLVqFeeffz4Gg4Hs7Gyys7Njps9qa2sRQqhELCMj46wkW7IsU1VVhRCC8vLyUx7ZcjYiHA7T3NxMQUEBRUVF9Pf388Ybb/CHP/wBr9eLyWTigQceOKM0V6cLUXL14IMPcvfdd7Nz507mzZsHwOrVq5kxYwZ2ux29Xk8gEMBsNnPRRRfhcrl45513+MlPfsJ9991HamqqeuPk8Xh44IEHkqHsZymSLcIkkhiDCAaDbNy4kdWrV7N+/XokSWL58uVcf/31LFmyJKayI4TA5XLR2dlJV1cXsiyTnZ1Nbm4uGRkZZ8X4eDgcpqqqCp1OR2lp6Vmx5tONQCDAjh07SE9PZ+bMmSqBEELwgx/8gKeffppVq1bxxhtv0NXVxbJly/jud7+rpkSMFQyvXNXV1XHDDTewdOlS7rjjDqZPn86XvvQlnnrqKR566CFuvvlmdXLQ6/Vy6623Mm/ePI4cOcIzzzzDH//4Rz760Y8CET+xgYGBmNDsJM4unH23oUmcc4h6OY38L+pivHTp0rjnvvKVr8Qco7m5mWuvvRabzUZOTg7f/e531fiJKDZt2kR5eTlms5lp06bx5JNPnqqXeMbBZDJx9dVX88c//pG2tjaeeeYZTCYTX/rSl5gyZQpf+cpX2LBhA4FAAEmSSE9PV8OHy8rKMJlMNDQ0sHnzZmpra+ns7FRDa880hEIhdu7ciV6vT5Kr40QgEGDnzp2kpqbGkauf//znvPDCC2zbto0//vGPNDY2snXrVubOnRv3nRsLiL43NTU1dHZ2YrPZuO2225g+fToAd9xxB5dddhlf+9rXuO+++6iurqavr4+nnnqKt956i5kzZ/Lwww+Tk5PDX/7yF/W4FoslSa7OciQrWEmcdnR3d8dcnHfv3s0VV1zBm2++ydKlS1m6dClFRUXcdddd6jY2m001MZRlmdLSUvLy8vjVr35Fe3s7n/70p/niF7/IL37xCyCSOTZnzhy+8pWv8IUvfIGNGzfyzW9+k5dffpmrrrrq1L7gMxiyLPPvf/+bF154gXXr1jE0NMTVV1/NqlWruPzyy2N8e4QQDA0NqZUtv99PVlYWubm5ZGVlnREtuGgWo9lspqSk5KxsbZ5qBINBduzYQUpKCnPmzIkZdLjnnnv4/e9/z+bNm5kxY8ZpXOWZhQMHDlBUVERGRoYadzMc9fX1/OY3v+FPf/oTJpMJs9mM2+1mxYoVrF27FoDLL7+c1tZWamtrz4jvThL/OZIEK4kzDt/85jd56aWX2L9/P5IksXTpUkpLS3nggQc0t3/llVdYvnw5bW1t6h3fo48+yp133kl3dzcmk4k777yTl19+md27d6v73XTTTbhcLjZs2HAqXtZZB0VR2L59u0q2uru7ueqqq1i1ahVXXnlljFmpEAK3263mI/p8PjIyMsjNzf1AJpYnEoFAgMrKSmw2W5xVRRLaCIVC7NixQ82vHP6e/e///i8PPviganCbxDH09vby+OOP87vf/Y7Ozk5efPFFLrvssrjP3IYNG9i6dSvBYJDJkyerlfi6ujpuuukmpk2bxnPPPYfBYDgnJ3jHGpIEK4kzCsFgkIKCAr797W/zwx/+EIi0CPfs2YMQgry8PK677jp+8pOfqJM1P/3pT/nHP/5BdXW1epxDhw4xZcoUKisrKSsrY8mSJZSXl8eQtCeeeIJvfvObDAwMnMqXeFZCURR27tzJ6tWrWbNmDS0tLVxxxRWsXLmSa665Ji4SxePxqJUtt9tNRkaGKpI/FbYI0aDrlJQUZs+enSRXx4FoK9VqtcYR0t/+9rfcd999vPHGGzGRMkkcQ1dXl5rZumDBAv74xz/GBGAnQkNDA3/4wx/47W9/y+rVq7nuuutOwWqTOBVI1iGTOKOwbt06XC4Xn/3sZ9XHPvGJTzBx4kQKCgqoqanhzjvvZO/evaxZswaAjo6OOK1C9N8dHR2jbjM4OIjP5zunI1JOBHQ6HQsWLGDBggX84he/oLa2lhdeeIFf//rXfO1rX+Oyyy5jxYoVLF++nLS0NOx2O1OmTGHKlCl4vV66urpoa2ujoaFBdQzPycnBbDaf8LX6fD527txJeno6s2bNSlYCjgOhUEhtpY4kV4899hj33HMPr7/+epJccczjyuPx4PV6kSSJrKwscnJyuOmmm5AkiTvvvJMvf/nL/OEPf2D8+PHAMTH8cFH8c889x1133UVbWxu/+93vkuTqHEOSYCVxRuFPf/oTV199NQUFBepjX/rSl9T/P3fuXPLz87nssstobGyMietI4tRAp9NRUlJCSUkJd911F/X19bzwwgs88sgjfP3rX+fiiy9m1apVLF++nKysLGw2mxoK7Pf76erqoqOjg71795Kamqp6bZ2IWBKfz8eOHTvIyspixowZSXJ1HIhOWBqNxjid2uOPP85///d/8+qrrzJ//vzTuMozA1FytXXrVv7nf/6HmpoaHA4H06dP56GHHmLSpEnccsstGI1GvvOd73Drrbfypz/9iQkTJqifxej/hsNhsrOzueCCC7j66qu5/vrrT+dLS+IkIFk3T+KMQVNTE6+//jpf+MIXRt0uOgYezRfLy8ujs7MzZpvov6Pmh4m2cTqdyerVfwBJkpg1axY//elPqaqqYs+ePVx66aU8+eSTTJs2jWuvvZbf//73dHR0IITAYrEwYcIEFixYwEUXXUReXh49PT38+9//5p133uHw4cN4vd4PtRaPx8N7771HTk5OklwdJ6LeYHq9Po5cPfXUU/zgBz/g5ZdfZtGiRadxlWcOdDod77zzDldeeSVut5tbbrmFZcuWsWfPHioqKnjvvfdISUnhpptu4v7776eyspJbb71V/a0aDoPBwKWXXsqDDz6YJFfnKJIEK4kzBk888QQ5OTlce+21o24X1Vrl5+cDsHjxYmpra+nq6lK3ee2113A6ncyaNUvdZmSe12uvvcbixYtP4CsY25AkienTp/ODH/yAd999l3379rF8+XKef/55ioqKuOqqq3jooYdoaWlBCIHZbKawsJCKigqWLFnC+PHj6evr4+2332b79u0cPHgQj8dzXOd2u91qTt7wKJckEiNKriRJirOveO6557jjjjtYv349F1100Wlc5ZmFgYEBvvvd73LxxRfz6KOPct999/Hggw8yZcoUZFnG4/EghCAlJYWPfexjPPDAA7z55pv87//+b8JjjqWQ8bGGpMg9iTMCiqIwefJkbr75Zu6991718cbGRp5++mmuueYaMjMzqamp4Vvf+hbjx49n8+bNwDGbhoKCAn75y1/S0dHBLbfcwhe+8IU4m4bbbruNz33uc7zxxhv813/9V9Km4RRACEFraytr1qxh9erVvP3225SXl7Nq1SpWrlzJxIkTYwhRKBSKycKzWq1qGLXD4YgjT0NDQ+zcuZPCwkKmTJmSJFfHAVmWqa6uRlEUysvLY8jV2rVr+fKXv8yaNWu48sorT+Mqzzx0d3dTUlLCD3/4Q26//XYAbr31VtasWcPf/vY3LrvsMqxWqxrcPDAwwLZt27jsssuSsUxjEEmClcQZgVdffZWrrrqKvXv3xqTYHzlyhE996lPs3r0bj8dDYWEh119/PT/+8Y9jJteampr46le/yqZNm7Db7XzmM5/h3nvvjfGT2bRpE9/61reoq6tj/Pjx/OQnP4kR0ydx8iGEoKOjg3Xr1rF69Wo2b97M3LlzWblyJatWrWLatGkxBCkcDtPT00NnZyc9PT1YLBZVs5WSksLg4CBVVVVMnDiRyZMnn8ZXdvZAURSqq6sJh8NxkUEvvfQSt956K3//+9/ft5I8FnHgwAFmzZrFunXruOaaa/jiF7/IM888w1/+8heWL1+OyWSis7OT73znO/z2t78lLS1N3TdKupIYO0gSrCSSSOK0QAhBb28v69ev54UXXuCNN96guLhYzUcc7iAOkQtUT08PXV1ddHd3o9frCYVCjB8/nuLi4mTl6jigKAq7du0iGAxSXl4eU1XZsGEDt9xyC0899RQ33HDDaVzlmYloGPpFF13EpZdeSigU4m9/+xtPPPEEK1euxGKxoCgK/+///T+ee+45/v73v6sShSTGJpIEK4kkkjjtiOYd/uMf/2D16tW89tprTJw4kZUrV3L99dfHmV42Nzezf/9+HA4HXq8XvV6vWj+kp6cnyZYGFEWhtrYWn89HRUVFDLnauHEjN998M3/605/4+Mc/fhpXeWZgeLVpuK0CwM9//nN+/vOfA/DQQw/x1a9+Vd1uy5YtfPvb36a4uJgnn3zylHi+JXHmIkmwkkgiiTMOg4ODvPTSS6xevZoNGzaQl5enthGPHDnC7bffzoYNG5g7dy6KotDf368am0qSpIZRp6enJ01GiZCraJu9oqIi5sK/ZcsWbrzxRh599FE+9alPncZVnhmIkqv29nZ+/etf09HRwdKlS7nyyitV49DbbrtNtSX55Cc/yYIFC3jqqad45JFH6Orq4p133iErKyuOnCUxtpAkWEkkkcQZDbfbzSuvvMKaNWtYv349fr+fiy66iJ/+9Kecd955MboWRVFwuVxqZI8QguzsbHJycsjMzByTZEsIwe7d/5+9O4+Ps6z3//+67nv2TDLZty5J032jG1tbBFSkXygKCIrbsYgom8pxRZTfQfQoR1wOKCLuRYXDDh4WUUTQA1SlQPc2bdo03bK0zZ7Z7/v6/TGZ6Uxm0jVp0vbzfDwi9r5nuWfSdN65rs/1udbR09PD6aefnhGuXn/9dS6//HLuuecerrnmmhG8ytGlra2N008/na6uLrxeL/v27eOCCy7g1ltv5bzzzqOzs5NvfOMb/OhHP0IphWma5OXlMWnSJJ5++mnGjBkjNVdCApYQ4sTw9NNP89GPfpQbb7yR1tZWnn32WbxeL+973/u49NJLWbRoUUbBttaarq6u1MhWPB5PbUZdUlJySnz4aa3ZsGEDXV1dLFiwIKNz/htvvMH73vc+vvvd76b2xDuVxeNxHA4Htm1z11138eyzz/Jf//VfTJkyhZUrV3LVVVcxceJEvvvd76ZWHr/44os0NTXR3NzMmWeeyRlnnEFxcbGEKwFIwBJCnACS4eqhhx7i0ksvBRKbOb/00ks88cQT/OEPf8A0TS655BIuv/xy3vGOd2TUGGmt6e7uTo1sRaPR1PYmpaWlGcHsZKG1ZuPGjXR0dHD66adnhKu3336bSy65hDvuuIPPfe5zI3iVI2v79u24XK7UzhE9PT08//zzPPzww4wfP5677747NcW3fv16zjnnHKqrq7nzzjt53/vel/Mxk93ehZCAJYQY9bZs2cK2bdsG7VkWi8X429/+xuOPP87TTz9NLBZj6dKlXH755Zx//vkZ4UJrTW9vb2pkKxQKUVJSQkVFBaWlpSdFvyKtNZs2bWL//v2cfvrpGc0s16xZw8UXX8zXvvY1vvSlL43gVY6sVatWpTaAv+mmmzBNkxtuuIGf/exn1NXVceedd/KBD3wAy7LQWuNwONi0aRPnnHMOZWVlfPe73x00ZAkBErCEECcZy7L4v//7v1TY6u3t5eKLL+ayyy5LNYJM19vbmxrZ6uvro6SkhPLycsrKyk7IVWBaazZv3pyqI0p/vRs2bOCiiy7i85//PF/72tdG8CpH1oYNG1i8eDELFy7ke9/7HjNnzgQSndpvuOEGHn74Yd797nezfPlyxowZAxyYQty2bRvnnXce4XCYX//617JBsxiUjGMKMcy+8Y1voJTK+Jo2bVrqfDgc5qabbqKkpAS/388VV1yRtW/ijh07WLp0KT6fj/Lycr785S8Tj8czbvPKK68wf/583G43kyZNYvny5cfj5Y06pmly/vnnc++999LU1MRzzz1HZWUlt9xyC7W1tSxbtownn3wytQ2P3++nrq6OhQsXsmjRIgoLC9m1axd///vfefPNN9m1axeRSGSEX9Xh0VqzZcsWWltbWbBgQUa4Sm5ddOONN454uDrUz8Rw2rJlC4sXL+bMM8/k+9//fipcAQQCAR544AE+9KEP8de//pVf/vKXqZ9Fh8NBLBajrq6OV199lUAgwKRJk47LNYsT08lXeCDEKDRz5kz+8pe/pP6cXvPz+c9/nueee47HHnuMQCDAZz7zGd7//vfz2muvAYkRmaVLl1JZWcnrr79Oc3MzH//4x3E6nRlbAS1dupTrr7+eBx98kJdeeolrr72WqqqqU3orINM0Wbx4MYsXL+b73/8+K1eu5IknnuCb3/wm1113He95z3u49NJLueiiiygoKMDn8zFhwgQmTJhAKBSira2NPXv2sGnTJgKBQGrLntG4f5zWmoaGBlpaWjj99NPx+Xypc1u3bmXp0qV84hOf4Bvf+MbIXWSag/1MDJft27dzzjnnMH/+fH7wgx9kNAJ99dVX+eMf/8i3v/1tfv3rX6O15j//8z8BuO6666isrMTpdBKLxaipqWHTpk2ponipuRK5yBShEMPsG9/4Bk8//XRqk+p0XV1dlJWV8dBDD3HllVcCsGnTJqZPn86KFSs4++yz+eMf/8gll1zCnj17qKioAOD+++/nlltuYe/evbhcLm655Raee+451q1bl3rsD33oQ3R2dvLCCy8cl9d5IrFtmzVr1vD444/z5JNPsm3bNt797ndz6aWXsnTpUgoLCzP6F4XDYdra2mhra6Ozs5OCgoLUlj0DpxxHytatW9m1axenn346eXl5qeNNTU1ceOGFfOADH+AHP/jBqOjLdLCfieHS2dnJtGnT8Hq9PP3008yZMyd17s033+Rd73oXCxcu5NFHH6WgoIBoNMonP/lJHnroIb72ta9xww03pIrhIbsBqRADSewW4jjYsmUL1dXV1NXV8dGPfpQdO3YAiX/YY7EYF1xwQeq206ZNY/z48axYsQKAFStWMHv27FS4AliyZAnd3d2sX78+dZv0x0jeJvkYIpNhGMydO5f//M//ZP369bz55puceeaZ3HfffUyYMIHLL7+c5cuXs2/fPrTWeDwexo8fz+mnn865555LdXU17e3tvPbaa/zjH/+gsbExNeU4ErZt28bOnTtZsGBBRrjatWsXF110EZdeeumoCVdJg/1MDJe9e/cybdo09u3bx4YNG1LH16xZw4UXXsi73/1ufvWrX6X2OHW5XPzmN79h2bJl3HXXXdx1113s2rUrdb/R9F6K0UkClhDD7KyzzmL58uW88MIL/PSnP6WxsZF3vOMd9PT00NLSgsvlytgUFqCiooKWlhYAWlpaMsJV8nzy3MFu093dTSgUGqZXdnJQSjFz5kxuv/123n77bdatW8f555/Pb37zGyZOnMgll1zCL37xC1paWtBa43K5GDt2LPPnz+e8885j/PjxdHZ2smLFClasWMHWrVvp7e3leE0ObN++nR07drBgwQL8fn/qeHNzMxdffDEXXnhhqiHmaHGwn4nhMnnyZH7+85+zePFirr32Wp544gnWr1/PBRdcwMKFC7n77rtTBe22bQOJacuf//znfOxjH+NHP/oR4XB42K5PnHykBkuIYXbRRRel/v9pp53GWWedRU1NDY8++uiomV4SCUoppkyZwte+9jVuvfVWGhsbeeKJJ3jkkUf44he/yMKFC7n00kt53/vex5gxY3A6nVRXV1NdXU08Hmfv3r20tbWxfft2PB5PqmYrPz9/WAJOU1MTjY2NLFiwgPz8/NTx1tZWli5dyjve8Q7uv//+UVcjdLCfiU9+8pPD9rxTpkzh3nvv5eabb+YjH/kIDoeDc889l/vuuy+1DY7WOvV+tbW10dLSwj333MNXvvIVKWoXR2R0/dQJcQooLCxkypQpNDQ0UFlZSTQapbOzM+M2ra2tVFZWAlBZWZm1qjD550PdpqCgQELcUVJKUVdXx5e//GVee+01GhsbufLKK3nmmWeYMWMG7373u7nnnnvYvn17qk9SVVUVc+bM4fzzz2fSpEkEg0FWrlzJa6+9xubNm+nq6hqyka2dO3eybds25s+fn5rWgsRU2CWXXMKCBQv45S9/OerCVS7pPxPDbdKkSdx7771cddVVhEIhzjnnnNTIVXpdVXNzM//xH//BRz/6UTo6Opg6deqwX5s4uYz+nzwhTjK9vb1s3bqVqqoqFixYgNPp5KWXXkqdr6+vZ8eOHSxcuBCAhQsXsnbtWtra2lK3efHFFykoKEitglq4cGHGYyRvk3wMcWyUUowbN46bb76ZV155hZ07d/Lxj3+cv/zlL8yZM4dzzz2X73//+2zZsgWtNaZpUlFRwWmnncZ5553HlClTiEajvPXWW7z66qvU19fT0dFx1GFr165dNDQ0MG/ePAKBQOp4e3s773vf+5g5cyYPPPDACbNdS/rPxPEwYcIE7rjjDq644gruuOMOfvGLXxCNRlPhqqWlhf/+7//m5z//OTfffDPjxo07LtclTjJaCDGsvvjFL+pXXnlFNzY26tdee01fcMEFurS0VLe1tWmttb7++uv1+PHj9V//+le9cuVKvXDhQr1w4cLU/ePxuJ41a5a+8MIL9apVq/QLL7ygy8rK9K233pq6zbZt27TP59Nf/vKX9caNG/VPfvITbZqmfuGFF4776z2V2Lat29ra9M9//nO9ZMkS7XK59OzZs/Vtt92mV65cqXt7e3VfX1/qq6enRzc1Nel//etf+rnnntPPP/+8Xrlypd6xY4fu6enJuO1gX5s3b9bPPPOM3r17d8bx3bt363nz5ulLL71UR6PRkX5rDupQPxPHy86dO/VVV12lTdPU99xzj9Za67a2Nn3rrbdqpZT+1a9+lbqtbdvH9drEiU8ClhDD7KqrrtJVVVXa5XLpMWPG6Kuuuko3NDSkzodCIX3jjTfqoqIi7fP59OWXX66bm5szHmP79u36oosu0l6vV5eWluovfvGLOhaLZdzm5Zdf1nPnztUul0vX1dXp3/zmN8fj5Yl+tm3r/fv369/85jf6ve99r/Z4PHratGn6lltu0f/4xz+yAlRPT4/esWOHXrlypX7++ef1c889p//1r3/ppqamQcPWli1b9DPPPKN37tyZcbylpUWfeeaZ+uKLL9bhcHik34pDOtTPxPG0e/du/dGPflQbhqHvuOMOfdttt2mllL7vvvtSt5FwJY6G9MESQohh0NXVxbPPPsuTTz7JCy+8QFVVFZdeeimXXXYZ8+bNy6iN0lrT2dmZ2h/RsizKysooLy+npKQE0zRpaWlhw4YNzJkzh5KSktR9+/r6uOyyy/D5fDzzzDOjsgnqaNfS0sJtt93Gr3/9awDuvvvu1CbYWvpdiaMkAUsIIYZZb28vzz//PE8++STPP/88xcXFvO997+Oyyy7jjDPOyKiV0lrT1dWVamwajUbx+/309PQwa9asjHYcwWCQK6+8EsMwePbZZzO6t4sj09raym233caCBQu4/vrrAaRLuzgmErCEEOI4CgaD/PnPf+aJJ57g2WefJS8vj/e+971cdtllLFy4MGPLGK0127dvp6GhAbfbTSwW46233iIQCPDe976X66+/nnA4zB//+MeMHlji6IRCodSqWwlX4lhJwBJCiBESDod56aWXeOKJJ/jf//1fTNPkve99L5dffjnnnHMOTzzxBD/5yU94/PHHKS8vp6+vj3vvvZff/e53NDU1EQgEuPPOO7nqqqsoKioa6ZcjhEgjAUsIIUaBWCzGK6+8wuOPP84f/vAHgsEgwWCQ6667jm9/+9u4XK7U7f7t3/6NhoYGrrzySp577jnWrl3Lu971Lm677TbOOeecEX4lQgiQgCWEEKPOn//8Zy699FLOOeccNm7cSG9vL0uXLuWSSy7h0UcfpbGxkb/+9a8UFxcDpDrOn3vuuZx55pkjfPVCCJCAJYQQo8rf/vY3LrnkEu677z7+7d/+DcuyWLFiBU888QS//e1vicVibN26lbKyspG+VCHEQUjAEkKIUeTHP/4xeXl5XHPNNVnnYrEYO3fupK6ubgSuTAhxJCRgCTEE7rvvPm666SbOPPNM/vnPf4705QghhBhhsgZViCHw4IMPUltby7/+9a/jsmHtaHTnnXdyxhlnkJ+fT3l5OZdddhn19fUZtzn//PNRSmV8JXsOJe3YsYOlS5fi8/koLy/ny1/+MvF4POM2r7zyCvPnz8ftdjNp0iSWL18+3C9PCCGOiAQsIY5RY2Mjr7/+Oj/84Q8pKyvjwQcfHOlLGhF/+9vfuOmmm/jHP/7Biy++SCwW48ILL6Svry/jdp/61Kdobm5Ofd11112pc5ZlsXTpUqLRKK+//joPPPAAy5cv5z/+4z9St2lsbGTp0qW8853vZNWqVfz7v/871157LX/605+O22sVQohDOp778ghxMvrWt76li4qKdCQS0TfccIOePHly1m327dunP/axj+n8/HwdCAT0xz/+cb1q1SoNZO0ZuHHjRn3FFVfooqIi7Xa79YIFC/Qf/vCH4/Rqhk5bW5sG9N/+9rfUsfPOO0/ffPPNg97n+eef14Zh6JaWltSxn/70p7qgoEBHIhGttdZf+cpX9MyZMzPud9VVV+klS5YM7QsQQohjICNYQhyjBx98kPe///24XC4+/OEPs2XLFt54443Uedu2ee9738v//M//sGzZMr797W/T3NzMsmXLsh5r/fr1nH322WzcuJGvfvWr/OAHPyAvL4/LLruMp5566ni+rGPW1dUFkGolkPTggw9SWlrKrFmzuPXWWwkGg6lzK1asYPbs2RnbwSxZsoTu7m7Wr1+fus0FF1yQ8ZhLlixhxYoVw/VShBDiiDkOfRMhxGDefPNNNm3axI9//GMAzjnnHMaOHcuDDz7IGWecAcDTTz/NihUruPvuu7n55psBuOGGG3jPe96T9Xg333wz48eP54033sDtdgNw4403cs4553DLLbdw+eWXH6dXdmxs2+bf//3fWbx4MbNmzUod/8hHPkJNTQ3V1dWsWbOGW265hfr6ep588kkgseluergCUn9uaWk56G26u7sztjoRQoiRJCNYQhyDBx98kIqKCt75zncCoJTiqquu4uGHH8ayLABeeOEFnE4nn/rUp1L3MwyDm266KeOx2tvb+etf/8oHP/hBenp62LdvH/v27WP//v0sWbKELVu2sHv37uP34o7BTTfdxLp163j44Yczjn/6059myZIlzJ49m49+9KP89re/5amnnmLr1q0jdKVCCDE8JGAJcZQsy+Lhhx/mne98J42NjTQ0NNDQ0MBZZ51Fa2srL730EgBNTU1UVVXh8/ky7j9p0qSMPzc0NKC15v/7//4/ysrKMr5uv/12ANra2o7PizsGn/nMZ3j22Wd5+eWXGTt27EFve9ZZZwGkVl5WVlbS2tqacZvknysrKw96m4KCAhm9EkKMGjJFKMRR+utf/0pzczMPP/xw1kgNJEa3LrzwwsN+PNu2AfjSl77EkiVLct5mYCgbTbTWfPazn+Wpp57ilVdeYcKECYe8z6pVqwCoqqoCYOHChXz729+mra2N8vJyAF588UUKCgqYMWNG6jbPP/98xuO8+OKLLFy4cAhfjRBCHBsJWEIcpQcffJDy8nJ+8pOfZJ178skneeqpp7j//vupqanh5ZdfJhgMZoxiDeyXlezO7XQ6s4q4TwQ33XQTDz30EH/4wx/Iz89P1UwFAgG8Xi9bt27loYce4uKLL6akpIQ1a9bw+c9/nnPPPZfTTjsNgAsvvJAZM2bwb//2b9x11120tLRw2223cdNNN6Vq0q6//nruvfdevvKVr3DNNdfw17/+lUcffZTnnntuxF67EEJkGelljEKciILBoM7Pz9fXXHNNzvOvvfaaBvTDDz+sH3/8cQ3ou+++O3Xesiz9rne9K6tNw/nnn6+Li4v1nj17sh6zra1tyF/HUAJyfiVf344dO/S5556ri4uLtdvt1pMmTdJf/vKXdVdXV8bjbN++XV900UXa6/Xq0tJS/cUvflHHYrGM27z88st67ty52uVy6bq6uqxWF0IIMdJkqxwhjsIjjzzChz70IZ5++mkuvfTSrPO2bVNZWcnZZ5/NU089xaJFi3jzzTe54YYbmDZtGv/7v/9LW1sbq1atYvny5amWDRs2bOCcc87BMAw+9alPUVdXR2trKytWrGDXrl2sXr36eL9UIYQQR0GmCIU4Cg8++CAejydnqwVIrBJcunQpDz74IJ2dnTz33HPcfPPNPPDAAxiGweWXX87tt9/O4sWL8Xg8qfvNmDGDlStXcscdd7B8+XL2799PeXk58+bNy+hmLoQQYnSTESwhRsjTTz/N5ZdfzquvvsrixYtH+nKEEEIMIQlYQhwHAxtgWpbFhRdeyMqVK2lpaZH2AkIIcZKRKUIhjoPPfvazhEIhFi5cSCQS4cknn+T111/nO9/5joQrMWJ+8pOf8L3vfY+WlhbmzJnDj3/8Y84888yRviwhTgoygiXEcfDQQw/xgx/8gIaGBsLhMJMmTeKGG27gM5/5zEhfmjhFPfLII3z84x/n/vvv56yzzuLuu+/mscceo76+PtWDTAhx9CRgCSHEKeiss87ijDPO4N577wUSK1/HjRvHZz/7Wb761a+O8NUJceKTrXKEEOIUE41GefPNNzMa2hqGwQUXXMCKFStG8MqEOHlIwBJCiFPMvn37sCyLioqKjOMVFRWpDvxCiGMjAUsIIYQQYohJwBJCiOPkJz/5CbW1tXg8Hs466yz+9a9/jch1lJaWYpomra2tGcdbW1uprKwckWsS4mQjAUsIIY6DRx55hC984QvcfvvtvPXWW8yZM4clS5bQ1tZ23K/F5XKxYMECXnrppdQx27Z56aWXWLhw4XG/HiFORrKKUAghjoPRtmrvkUceYdmyZfzsZz/jzDPP5O677+bRRx9l06ZNWbVZQogjJ41GhRBimCVX7d16662pYyO9au+qq65i7969/Md//ActLS3MnTuXF154QcKVEENEApYQQgyzg63a27Rp0whdFXzmM5+RZrdCDBOpwRJCCCGEGGISsIQQYpjJqj0hTj0SsIQQYpjJqj0hTj1SgyWEEMfBF77wBZYtW8bpp5+eWrXX19fHJz7xiZG+NCHEMJCAJYQQx4Gs2hPi1CJ9sIQQQgghhpjUYAkhhBBCDDEJWEIIIYQQQ0wClhBCCCHEEJOAJYQQQggxxCRgCSGEEEIMMQlYQgghhBBDTAKWEEIIIcQQk4AlhBBCCDHEJGAJIYQQQgwxCVhCCCGEEENMApYQQgghxBCTgCWEEEIIMcQkYAkhhBBCDDEJWEIIIYQQQ0wClhBCCCHEEJOAJYQQQggxxCRgCSGEEEIMMQlYQgghhBBDTAKWEEIIIcQQk4AlhBBCCDHEJGAJIYQQQgwxCVhCCCGEEENMApYQQgghxBCTgCWEEEIIMcQkYAkhhBBCDDEJWEIIIYQQQ0wClhBCCCHEEJOAJYQQQggxxCRgCSGEEEIMMQlYQgghhBBDTAKWEEIIIcQQk4AlhBBCCDHEJGAJIYQQQgwxCVhCCCGEEENMApYQQgghxBCTgCWEEEIIMcQkYAkhhBBCDDEJWEIIIYQQQ0wClhBCCCHEEJOAJYQQQggxxCRgCSGEEEIMMQlYQgghhBBDTAKWEEIIIcQQk4AlhBBCCDHEJGAJIYQQQgwxCVhCCCGEEENMApYQQgghxBCTgCWEEEIIMcQkYAkhhBBCDDEJWEIIIYQQQ0wClhBCCCHEEJOAJYQQQggxxCRgCSGEEEIMMQlYQgghhBBDTAKWEEIIIcQQk4AlhDipXX311dTW1o70ZRyx888/n/PPP3/YHn/79u0opVi+fPkhb7tlyxYuvPBCAoEASimefvrpYbuuYzHc75kQR0ICljjuli9fjlJq0K9//OMfqdsqpfjMZz5zWI/7zDPP8N73vpeKigpcLhfFxcWce+65/OAHP6C7u3u4Xs6o8p3vfOeoP/yuvvpq/H7/oOeP5HshTi7Lli1j7dq1fPvb3+Z3v/sdp59++ohdy4YNG/jGN77B9u3bR+wahDgcjpG+AHHq+uY3v8mECROyjk+aNOmIHse2bT75yU+yfPlyZs+ezY033si4cePo6elhxYoV3HbbbTz//PO89NJLQ3Xpo9Z3vvMdrrzySi677LKRvhRxjP785z+P9CUAEAqFWLFiBV//+tdHRcDesGEDd9xxB+eff37WyORoec+EAAlYYgRddNFFQ/Kb8F133cXy5cv5/Oc/zw9+8AOUUqlzN998M83Nzfz2t7895ucZrbTWhMNhvF7vSF/KiAiHw7hcLgxjdA/I9/X1kZeXd9i3d7lcw3g1h2/v3r0AFBYWjuyFHIbR8p4JATJFKE5wwWCQ7373u8ycOZPvfe97GeEqqaqqiltuuSXjWDwe51vf+hYTJ07E7XZTW1vL1772NSKRSMbtamtrueSSS3jllVc4/fTT8Xq9zJ49m1deeQWAJ598ktmzZ+PxeFiwYAFvv/12xv2T027btm1jyZIl5OXlUV1dzTe/+U201hm3tW2bu+++m5kzZ+LxeKioqOC6666jo6Mj5zX96U9/Sl3Tz372M5RS9PX18cADD6SmW6+++upUrc1gX0crGo3yH//xHyxYsIBAIEBeXh7veMc7ePnllzNud/755w/63Mn6n/b2dr70pS8xe/Zs/H4/BQUFXHTRRaxevTrjsV555RWUUjz88MPcdtttjBkzBp/Pl5oCfvrpp5k1axYej4dZs2bx1FNPHfbrWblyJUuWLKG0tBSv18uECRO45pprsp47+b1PylXLlPy+b926lYsvvpj8/Hw++tGP8pnPfAa/308wGMx6/g9/+MNUVlZiWVbqfUvWE7W2tuJwOLjjjjuy7ldfX49SinvvvfeI3svD8Y1vfIOamhoAvvzlL6OUSo0aDVbb9o1vfCPr71Vyejn5/XG73cycOZMXXngh6/67d+/mk5/8JNXV1bjdbiZMmMANN9xANBpl+fLlfOADHwDgne98Z+rvUfJ7kqsGq62tjU9+8pNUVFTg8XiYM2cODzzwQMZtkt/D73//+/z85z9P/btwxhln8MYbbxzx+yYEyAiWGEFdXV3s27cv45hSipKSksN+jFdffZXOzk6+9KUvYZrmYd/v2muv5YEHHuDKK6/ki1/8Iv/85z+588472bhxY9aHckNDAx/5yEe47rrr+NjHPsb3v/993vve93L//ffzta99jRtvvBGAO++8kw9+8IPU19dnjKZYlsX/+3//j7PPPpu77rqLF154gdtvv514PM43v/nN1O2uu+46li9fzic+8Qk+97nP0djYyL333svbb7/Na6+9htPpTN22vr6eD3/4w1x33XV86lOfYurUqfzud7/j2muv5cwzz+TTn/40ABMnTqSsrIzf/e53Ga8pFovx+c9/Pudv/AO/J4Pp7u7ml7/8JR/+8If51Kc+RU9PD7/61a9YsmQJ//rXv5g7dy4AX//617n22msz7vv73/+eP/3pT5SXlwOwbds2nn76aT7wgQ8wYcIEWltb+dnPfsZ5553Hhg0bqK6uzrj/t771LVwuF1/60peIRCK4XC7+/Oc/c8UVVzBjxgzuvPNO9u/fzyc+8QnGjh17yNfS1tbGhRdeSFlZGV/96lcpLCxk+/btPPnkk4f1XuQSj8dZsmQJ55xzDt///vfx+XzU1tbyk5/8hOeeey4VFCDxi8IzzzzD1VdfnfPvcUVFBeeddx6PPvoot99+e8a5Rx55BNM0U493pO/lwbz//e+nsLCQz3/+83z4wx/m4osvPmid3sG8+uqrPPnkk9x4443k5+fzox/9iCuuuIIdO3akfub37NnDmWeeSWdnJ5/+9KeZNm0au3fv5vHHHycYDHLuuefyuc99jh/96Ed87WtfY/r06QCp/w4UCoU4//zzaWho4DOf+QwTJkzgscce4+qrr6azs5Obb7454/YPPfQQPT09XHfddSiluOuuu3j/+9/Ptm3bMn7+hDgsWojj7De/+Y0Gcn653e6M2wL6pptuGvSx7rnnHg3op59+OuN4PB7Xe/fuzfiybVtrrfWqVas0oK+99tqM+3zpS1/SgP7rX/+aOlZTU6MB/frrr6eO/elPf9KA9nq9uqmpKXX8Zz/7mQb0yy+/nDq2bNkyDejPfvazqWO2beulS5dql8ul9+7dq7XW+v/+7/80oB988MGMa3rhhReyjiev6YUXXsh6P/Ly8vSyZcsGfb+SbrzxRm2aZsZrTV7rwb7SvxfxeFxHIpGMx+3o6NAVFRX6mmuuGfS5X3vtNe10OjNuEw6HtWVZGbdrbGzUbrdbf/Ob30wde/nllzWg6+rqdDAYzLj93LlzdVVVle7s7Ewd+/Of/6wBXVNTc9D346mnntKAfuONNwa9TfK507+/yesE9G9+85vUseR7+dWvfjXjtrZt6zFjxugrrrgi4/ijjz6qAf33v/89dey8887T5513XurPyb9fa9euzbjvjBkz9Lve9a7Unw/3vcx13bkkb/e9730v4/iyZctyvq+33367HvjRAmiXy6UbGhpSx1avXq0B/eMf/zh17OMf/7g2DCPn9yH58/vYY4/l/D5onf2e3X333RrQv//971PHotGoXrhwofb7/bq7uzvjNZaUlOj29vbUbf/whz9oQD/zzDM53hkhDk6mCMWI+clPfsKLL76Y8fXHP/7xiB4jOTU08LfqtWvXUlZWlvG1f/9+AJ5//nkAvvCFL2Tc54tf/CIAzz33XMbxGTNmsHDhwtSfzzrrLADe9a53MX78+Kzj27Zty7rO9OLg5HRJNBrlL3/5CwCPPfYYgUCA97znPezbty/1tWDBAvx+f9a024QJE1iyZMlB35vB/Pa3v+W+++7jrrvu4p3vfGfGOY/Hk/U9SX4NZJpmagTMtm3a29uJx+OcfvrpvPXWWzmfu6WlhSuvvJK5c+dy3333pY673e7UqJ9lWezfvx+/38/UqVNzPtayZcsyas6am5tZtWoVy5YtIxAIpI6/5z3vYcaMGYd8T5L1Rc8++yyxWOyQtz9cN9xwQ8aflVJ84AMf4Pnnn6e3tzd1/JFHHmHMmDGcc845gz7W+9//fhwOB4888kjq2Lp169iwYQNXXXVV6tiRvpfHywUXXMDEiRNTfz7ttNMoKChI/bzYts3TTz/Ne9/73py1mUcznf38889TWVnJhz/84dQxp9PJ5z73OXp7e/nb3/6WcfurrrqKoqKi1J/f8Y53ALl/poU4FJkiFCPmzDPPPOYi9/z8fICMDytIrERMhoLf/va3GVNkTU1NGIaRtVqxsrKSwsJCmpqaMo6nhygg9QE+bty4nMcH1kwZhkFdXV3GsSlTpgCklppv2bKFrq6u1JTZQG1tbRl/zrX68nCsWrWK66+/ng9/+MNZARMSoemCCy447Md74IEH+MEPfsCmTZsygkmu64vH43zwgx/EsiyefPJJ3G536pxt29xzzz3cd999NDY2puqQgJxTxgMfP/k9mzx5ctZtDydYnHfeeVxxxRXccccd/Pd//zfnn38+l112GR/5yEcyrvNIOByOnNOTV111FXfffTf/+7//y0c+8hF6e3t5/vnnU9NSgyktLeXd7343jz76KN/61reARDBzOBy8//3vT93uSN/L42XgzxFAUVFR6udl7969dHd3M2vWrCF7zqamJiZPnpy1ACI5pXion/Vk2Br4My3E4ZARLHFCmzZtGpD4TT6d3+/nggsu4IILLsgKN0mH+xvxYLVdgx3XA4rXD4dt25SXlw86epReqwUc1YrBjo4OrrjiCqZMmcIvf/nLI77/QL///e+5+uqrmThxIr/61a944YUXePHFF3nXu96FbdtZt//yl7/MihUrePTRR7OCx3e+8x2+8IUvcO6556bqs1588UVmzpyZ87GGesWkUorHH3+cFStW8JnPfIbdu3dzzTXXsGDBglR4H+zvS3qASZc+kpTu7LPPpra2lkcffRRI9G8LhUIZo1CD+dCHPsTmzZtZtWoVAI8++ijvfve7KS0tTd3mSN/Lo3Wk78dQ/rwMlxPhGsWJQ0awxAntHe94B4FAgIcffphbb731sJbq19TUYNs2W7ZsySiObW1tpbOzM7VqaqjYts22bdtSo1YAmzdvBkitwpo4cSJ/+ctfWLx48TGFh8E+9Gzb5qMf/SidnZ385S9/wefzHfVzJD3++OPU1dXx5JNPZjzvwCJsgIcffpi7776bu+++m/POOy/nY73zne/kV7/6Vcbxzs7OjPAwmOT3bMuWLVnn6uvrD3n/pLPPPpuzzz6bb3/72zz00EN89KMf5eGHH+baa69NjWZ0dnZm3GfgKMjh+OAHP8g999xDd3c3jzzyCLW1tZx99tmHvN9ll13Gddddl5om3Lx5M7feemvGbY71vTxcRUVFWe8FHN37AVBWVkZBQUHWL0sDHclUYU1NDWvWrMG27Yx/GzZt2pQ6L8RwkREscULz+Xx85StfYd26dXz1q1/N+ZvmwGMXX3wxAHfffXfG8R/+8IcALF26dMivM7mEPnk99957L06nk3e/+90Aqamz5NRPung8nvODLJe8vLyct73jjjv405/+xP/8z/8c9fTiQMnf9tPf33/+85+sWLEi43br1q3j2muv5WMf+1jWqq30xxr4fXrsscfYvXv3YV1LVVUVc+fO5YEHHqCrqyt1/MUXX2TDhg2HvH9HR0fW8ydXQSZbd9TU1GCaJn//+98zbpdeS3a4rrrqKiKRCA888AAvvPACH/zgBw/rfoWFhSxZsoRHH32Uhx9+GJfLldVU9ljfy8M1ceJEurq6WLNmTepYc3PzEbXGSGcYBpdddhnPPPMMK1euzDqffE3JXmKH8zNx8cUX09LSklG3Fo/H+fGPf4zf788Z9oUYKjKCJUbMH//4x9RvkukWLVqUMa23cuVK/vM//zPrdueffz7nnHMOX/3qV9m4cSPf+973Ukv1x44dS0dHB2+99RaPPfYY5eXleDweAObMmcOyZcv4+c9/TmdnJ+eddx7/+te/eOCBB7jsssuyCr+Plcfj4YUXXmDZsmWcddZZ/PGPf+S5557ja1/7GmVlZUCiBui6667jzjvvZNWqVVx44YU4nU62bNnCY489xj333MOVV155yOdasGABf/nLX/jhD39IdXU1EyZMwOfz8a1vfYtzzz2XtrY2fv/732fc52Mf+9hRva5LLrmEJ598kssvv5ylS5fS2NjI/fffz4wZMzJq4j7xiU8ApKas0iW/15dccgnf/OY3+cQnPsGiRYtYu3YtDz744KDTu7nceeedLF26lHPOOYdrrrmG9vZ2fvzjHzNz5sysGr2BHnjgAe677z4uv/xyJk6cSE9PD7/4xS8oKChIBfJAIMAHPvABfvzjH6OUYuLEiTz77LNZ9XGHY/78+UyaNImvf/3rRCKRw5oeTLrqqqv42Mc+xn333ceSJUuyGoAOxXt5OD70oQ9xyy23cPnll/O5z32OYDDIT3/6U6ZMmXLUxfTf+c53+POf/8x5553Hpz/9aaZPn05zczOPPfYYr776KoWFhcydOxfTNPnud79LV1cXbrebd73rXTnrFz/96U/zs5/9jKuvvpo333yT2tpaHn/8cV577TXuvvvuVA2nEMNihFYvilPYwdo0MGDZ+MFu961vfSvjcZ966il98cUX67KyMu1wOHRhYaE+55xz9Pe+972Mpftaax2LxfQdd9yhJ0yYoJ1Opx43bpy+9dZbdTgczrhdTU2NXrp0adZrIEf7iFzL2ZctW6bz8vL01q1b9YUXXqh9Pp+uqKjQt99+e9ZSeq21/vnPf64XLFigvV6vzs/P17Nnz9Zf+cpX9J49ew55TVprvWnTJn3uuedqr9erAb1s2bJUe4HBvgZe62AGvmbbtvV3vvMdXVNTo91ut543b55+9tlns5bvJ9tKHOx7HQ6H9Re/+EVdVVWlvV6vXrx4sV6xYkXWsvvka3nsscdyXuMTTzyhp0+frt1ut54xY4Z+8sknB20nkO6tt97SH/7wh/X48eO12+3W5eXl+pJLLtErV67MuN3evXv1FVdcoX0+ny4qKtLXXXedXrduXc42DQd7L7XW+utf/7oG9KRJk3KeH/jak7q7u1Pf3/T2A0mH+14ea5sGrRNtMGbNmqVdLpeeOnWq/v3vfz9om4Zc7VZqamqy2oo0NTXpj3/847qsrEy73W5dV1enb7rppoyWIL/4xS90XV2dNk0zo2VDrvestbVVf+ITn9ClpaXa5XLp2bNnZ73mg71GQN9+++2Dv0FCDEJpLdV7QgyXq6++mscff/yQIyhCCCFOLlKDJYQQQggxxCRgCSGEEEIMMQlYQgghhBBDTGqwhBBCCCGGmIxgCSGEEEIMMQlYQgghhBBDTAKWEEIIIcQQk4AlhBBCCDHEJGAJIYQQQgwxCVhCCCGEEENMApYQQgghxBCTgCWEEEIIMcQkYAkhhBBCDDEJWEIIIYQQQ0wClhBCCCHEEJOAJYQQQggxxCRgCSGEEEIMMQlYQgghhBBDTAKWEEIIIcQQk4AlhBBCCDHEJGAJIYQQQgwxCVhCCCGEEENMApYQQgghxBCTgCWEEEIIMcQkYAkhhBBCDDEJWEIIIYQQQ0wClhBCCCHEEJOAJYQQQggxxCRgCSGEEEIMMQlYQgghhBBDTAKWEEIIIcQQk4AlhBBCCDHEJGAJIYQQQgwxCVhCCCGEEENMApYQQgghxBCTgCWEEEIIMcQkYAkhhBBCDDEJWEIIIYQQQ0wClhDioGzbRms90pchhBAnFMdIX4AQYvSybZu+vj7i8ThOpxOHw4HD4cA0TZRSI315QggxaknAEkJk0VpjWRaxWAzLsrAsC4BoNIplWXR0dFBdXY3T6cQ0TQlcQggxgAQsIUQGrTVdXV3s3r2burq61HGHI/HPRTQaZdOmTZSVlRGNRlFKYRgGpmlK4BJCiH4SsIQQKclRq2AwyK5du5g0aRLt7e309PRQVlaG3+/HMBKlmw6HI1WbZds2sVgsI3ClTydK4BJCnGokYAkh0FoTj8eJx+MAGIaBbdts3LiRXbt2kZ+fz86dO1FKkZ+fj9aa3t5e8vLyUEphmmbqcSARuKLRKJFIRAKXEOKUpLQsDxLilJYcfbJtGwClFK2traxevZr8/HymT5+Ow+HA6XTS09PD3r172bFjR2pasLCwkKKiIoqKivD5fBnBKT1w2badOieBSwhxspOAJcQpSmudEa6SU3979uxh/fr1AFxwwQVEo1FisRhutxuASCTCa6+9xnnnnUdPTw8dHR10dnbS1dWFw+HICFxerzcrcCW/0gOdYRip+i2Hw4FhGBK4hBAnNJkiFOIUpLVOrRCExIiSZVls2LCBffv2MW3aNDZv3pwKXelhJ/n/lVIUFhZSWFgIJOq3uru76ejooLW1lc2bN+NyuSgqKkqFrvTAZZpmRuAKh8Opx00GruQIlwQuIcSJRgKWEKeY5KiVZVmp4NLV1cXq1avxer0sWrSIWCx2yOaiA8+bppkauYJE4Orq6qKjo4M9e/ZQX1+P2+3OCFwej+ewAldyZEsClxDiRCEBS4hTRLK3VTwez5gSbGxspKGhgbq6Ourq6lBKEY/HUwFqYJA53GBjmibFxcUUFxcDEI/HU4Fr165dbNy4Ea/XmxG43G53zsBl27YELiHECUUClhCngFxTgrFYjLVr19LT08Ppp5+eGnmCRIgZbAQrGWSOtHzT4XBQUlJCSUkJkAhcnZ2ddHR0sGPHDjZs2IDP50uNghUWFuJyuQ4ZuAzDyCqal8AlhBhpErCEOMkle1slR62UUuzfv581a9ZQWFjI4sWLcTqdGfcZGE5yhaljXR/jcDgoLS2ltLQUgFgslgpcjY2N9PX1kZeXlxG4nE5nzsCV7Daf3hYivWheKSWBSwhxXEnAEuIkld7bSmuNYRhordmyZQtNTU1MmzaNsWPH5gwehzOCNdScTidlZWWUlZUBiY7xycC1detWgsEgfr8/I3Alw1NyujM9cMXj8VSwGjilKIFLCDHcJGAJcRKybZt4PJ4xJRgOh1m9ejXxeJyzzz6b/Pz8Qe9/sGnAo50iPFIul4vy8nLKy8uBRHuIjo4OOjo62LJlC+FwmPz8/FT9VmFhYSo8DQxc8XicWCw2aOBK3l4IIYaKBCwhTiLpva201qlA0dLSwrp166isrGT69OmpzuuDOZwQdbxb6LndbiorK6msrAQgHA6nAld9fT2RSISCgoJU4AoEAhK4hBAjRgKWECeJgYXsSils22bTpk00Nzcza9asVDg5lMMZwRppHo+HqqoqqqqqAAiFQqnAtXHjRqLRKIFAICNwJWvQcgWutrY2Ojo6mDRpUipoSeASQhwtCVhCnARy9bbq7e1l1apVmKbJokWL8Pl8R/y4IzlFeKS8Xi9er5fq6mq01hmBa8+ePcTjcQKBQKqGKz8/PyNwWZZFX18fSqnUxtVwYFsfCVxCiCMhAUuIE9hgva127tzJpk2bqKmpYdKkSUccCEbjFOGRUErh8/nw+XyMGTMGrTXBYDAVuHbu3Ilt2xmBKzmlmmz7AJlTrtFoNDWlmD6dmCy0F0KIdBKwhDhB5eptFY/HWb9+PR0dHcybNy/VAuFIHSpgHWyV4WiklCIvL4+8vDzGjh2L1pq+vr5U4GpqasK2bUzTZMeOHRQVFeH3+1P1WUnpgSsWi6UeWwKXEGIgCVhCnIBs2yYajWb0turs7GT16tXk5eWxaNGi1ObMR+NQAeFEDxBKKfx+P36/n3HjxqG1prGxkdbW1lQfruRei8kRrry8vIMGruQIl2EYmKaZ6sOVLLQXQpxaJGAJcQJJTgkmVwkmp7K2bdvG1q1bmTRpErW1tcf8gZ4+gjXYY51II1iHopTC4/Hg8XiYM2cOtm3T09NDR0cH+/fvZ+vWrZimmRG4fD6fBC4hxKAkYAlxgsjV2yoajbJmzRqCwSBnnHEGhYWFQ/JchwpYJ9oU4ZEyDINAIEAgEAAS7313dzcdHR3s3buXhoYGHA5Hxj6KXq83I3Al359cgSt9SlEClxAnJwlYQoxyg/W22rdvH2vWrKGkpIR58+bhcAz9j/Px7uY+0gZ7XYZhUFhYmAqwlmWlAldLSwubN2/G5XJlBS4gZ+CKRqMZ2/pI4BLi5CMBS4hRLH27GzgwcrR582Z27NjB9OnTGTNmzJB/ICdD3Im6ivBoHMnrMU0zNVUIicDV1dWVaglRX1+P2+3OCFwejyd13/Tns22bSCSS1RZCApcQJzYJWEKMUslRK9u2gcQHbzAYZPXq1di2zcKFC/H7/cN6DSfLKsLhZpomxcXFFBcXAxCPx1OBa9euXWzcuBGv15uxj2JyEUIyRCWbnmqtswJX+sbVyUUNQojRTQKWEKNMrt5WSimam5tZv3491dXVTJ069ZDb3Ryrkdjw+WThcDgoKSmhpKQESASu5MbVTU1NrF+/Hp/PlxG4XC5X6n0dGLjC4TBAakrR6XRmND2V74cQo48ELCFGkWRvq1WrVjFx4kTy8vKwbZuNGzfS2trK7NmzqaioOC7XcqpNEcLwBUeHw0FpaWmqL1ksFksFrsbGRvr6+sjLy8sIXE6nUwKXECcwCVhCjBLp293s37+fmpqa1HY3LpeLRYsWpQqnj4eDfUjLFOGxcTqdlJWVUVZWBkA0Gk0Frq1btxIMBvH7/RmBK72B6cECV66NqyVwCXH8ScASYoTl6m2llKKlpYWdO3dSW1vLxIkTj/v+dwNDVHrLBglYQ8vlclFeXk55eTkAkUgk1WV+y5YthMNh8vPzUwXzhYWFGcXv6YHLtu1U4Epu+yOBS4jjTwKWECNosO1uYrEYu3fvZv78+ak6nuMtPUQlP7xP5g/m0RQY3W43lZWVVFZWAhAOh1OBq76+nkgkQkFBQSpwBQKBQQOXZVm0t7fT3NzM9OnTJXAJcZxIwBJihCRHrdIL2Ts6Oli9ejVKKWbMmDFi4QoOXeQ+mgLJyc7j8VBVVUVVVRUAoVAoFbg2btxINBpNbVxdWFhIIBBI/Z0yDAPbtgkGgyilsCwLy7JSfbiSU4rp+yhK4BLi2EnAEuI4G9jbKjn1t3XrVrZt28bkyZPZuXPnsK8SPJRkiDoVO7mPdl6vF6/XS3V1NVrrjMC1a9cuLMtKBa6ioqJUiE9+wYFRyeSIaTJYDazhksAlxNGRgCXEcTSwt5VSikgkwpo1awiHw5x55pkEAgH27NkzKgLMqdam4UR8XUopfD4fPp+PMWPGoLUmGAymAtfOnTuxLAvDMGhqaqKoqAi/358xwgWHH7iOdy2gECcqCVhCHAfp292kTwm2tbWxdu1aysrKmD9/fmq7m9EwQnQqtmk4GSilyMvLIy8vj7Fjx6K1pqmpiebmZrq6umhqakJrnbFxtd/vTwWqQwWu9OlECVxCDE4ClhDDLFchu9aaTZs2sWvXLmbOnEl1dXXGfZJ1MyNJpghPDkop3G43Ho+H0047Da01PT09GX24lFIZgSsvL2/QwJXcuBoObOsjgUuIbBKwhBhG6b2tkqNWfX19rF69GoBFixaRl5eXdT+l1KgJWMn/P/DcyeZkDoy2bWe02CgoKKCgoIDx48dj2zY9PT10dHSwf/9+tm7dimmaGYHL5/MdMnClj3Cl76MogUucqiRgCTEMBtvuZs+ePaxfv56xY8cyderUQT98RsMIUfID2bZturq6Utu5JI309YnDd7AWG4ZhEAgECAQCQOL73d3dTUdHB3v37qWhoQGHw5GxcbXX680ZuJK/UMRiMYCswJXeLFWIk50ELCGGWK4pQcuy2LBhA3v37mXOnDmphpKDSU4jjqRkAf5bb71FT08PlmVRUFBAUVFRaqn/yeZk/fA/kh5mhmFQWFhIYWEhkGgnkgxcLS0tbN68GZfLlTNwpa98TQ9cyREuwzByrlIU4mQkAUuIIZSrt1V3dzerVq3C4/GwePFiPB7PIR9nNEwRWpbFpk2bKCsrY9q0aSilUnU7oVCITZs20dLSkppGys/Pl+mgUepYmsSappn6HkPi70VXVxcdHR3s2bOH+vp63G536jZFRUW43e4jClxOpzM1pSiBS5wsJGAJMQTSe1slt7sB2L59O1u2bKGuro66urojGkUYqREsrTUNDQ0Eg0HGjx/PlClTCIVCOJ3OVLPLYDBIWVkZpmnS0dHBjh070FpnfMgmC6XFyBvKLvymaVJcXExxcTEA8Xg8Fbh27tzJhg0b8Hq9GfsoHkngGljDJX+HxIlKApYQx8i2beLxeMaUYCwWY+3atfT09HD66aenfvs/XCM1ghUOh1mzZg2RSCS12XAuhmHgcrmoqqpKtQLo7e2lvb09VSidrNtJfh3PjapFpuHc5sjhcFBSUpLadSAej6dGOpuamli/fj0+ny8jcLlcrozAlfxlwrZtotFoqsu8BC5xIpOAJcRRSv8NPPkBppSivb2d1atXU1hYyKJFizIKww/XSIxg7d+/n9WrV1NaWsr8+fNZuXLlYTcaVUqRn59Pfn4+NTU1qcL4jo4Ompubqa+vx+PxZASuo3lfhtNI17wNp+O5j6TD4aC0tJTS0lIAYrFYRkuIvr4+8vLyMgKX0+kEkMAlTioSsIQ4CgML2ZOr/hoaGti+fTtTp05l3LhxR/2P//EcwUq/7unTpzNmzJhUWDzYB/PBAolhGBl1O7lGNZIjZMkP2WSTVTH0RnKjbqfTSVlZGWVlZQBEo9HU34WtW7cSDAbJz89PFcyn/11ID1zJr0gkktGHK1m/5XA4ZONqMarIv2hCHKFcva1CoRBr1qwhGo1y9tlnk5+ff0zPcbxGsNK36Rl43UO52fPAUY1oNJraymXLli2Ew+HUCsWioqLUZsXH28n64ZxeFzjSXC4X5eXlqZW0kUgk6+/CwMCVPlJlmmZG4AqHwwA0NzdTWlpKfn5+RtPTk/V7KkY/CVhCHKbBelu1traybt06KioqWLBgwZCMxByPEaz9+/ezZs0aiouLmTdvXtZ1D/xgSg9Ux/qh5XK5qKiooKKiAiBjs+I9e/YQj8czGl3m5+fLB+UxGMkRrENxu91UVlZSWVkJJOoAk38X6uvriUQiqfBdWFhIIBDIGbh27tyJ3+9PTTcmpxSdTqcELjEiJGAJcRhy9baybZv6+nr27NnDzJkzqaqqGrLnS/bOGg5aa7Zt28a2bduYNm0aY8eOPeLtcIa6EarX68Xr9VJdXY3Wmr6+vtSH7Pbt21FKZdRvJTuLi8MzmgPWQB6PJ7VaFbLDdywWIxAIZASu5M+j0+nE6XTmHOEabOPqE+V9ESceCVhCHEKy0DZ91Kq3t5fVq1djGAaLFi3C5/MN6XMO1whWckowFApx1llnUVBQcNBrGInNnpVS+P1+/H4/48aNy9jKJdlZ3Ol0psJWcXExbrd7WK7lZDGapgiP1MDwnR64du3ahWVZBAIB4vF4qoA+PTilTynati2BSxw3ErCEGERySjC5SjD5AbVr1y42btzI+PHjmTx58rB8cA3HVjnJ1Y1FRUU5pwRzOdxVhMMpfSuX2trajEaXu3fvZtOmTRl9l4qKilLTREdCVhGOfkopfD4fPp+PMWPGoLUmGAymAtfmzZupr69PjXAVFRXh9/sPGrgikQjhcBjDMLJWKUrgEsdCApYQOQy23c369evZv38/c+fOTa2KGg5DWeSePiV4JKsbj+cU4ZEY2OhyYBuAdevWkZ+fn7FCMb3B5akofbPnk4lSiry8PHw+H5s3b+bMM88kHo+nAldTUxNa64x6Pr/fn1olm5QMXMktoJJtIZIjXOn7KJ6M76MYHhKwhEgzWG+rrq4uVq9ejdfrZfHixcM+JTVUU4TRaJQ1a9bQ19fHmWeemdrQ93CvYSSmCI/UwDYA6avSkkXSyRGN4uLig27pc7J+eJ4sI1iDSf6smKaJx+NJTS9rrenp6ckI4EqpjMCV3HFg4MbVyd0ZYrFY6nyufRRP5vdVHBsJWEL0S9/uBg582DY2NtLQ0MDEiROZMGHCcfkHdShGsDo6Oli9ejWBQIBFixYd8bTZwV7nSI5gHUr6qrRcNTu2bac+YIuLi0+JLX1OlYA1MDgrpSgoKKCgoIDx48dn1PMldxwwTTMjcCUXUBxN4DpR69zE8JCAJQQHCtlff/115s+fj9frJRKJsHbtWvr6+jjjjDMoLCw8btdzLCNYWmsaGxvZunUrU6ZMYfz48Uf14XqwazhRPqxz1ez09vamAldjY2OqKapt26M2NB6rUyVgHeo1ptfzJe/X3d2dsYAiucVTMnR5vV4JXOKoSMASp7T0KUHbtunt7cW27VSPqKKioqMa/TlWRzuCFY1GWbt2Lb29vUc8JThQ8sPqaDq5j1bpW/okRzSSH7DNzc2Ew2Fef/31jBWKo21Ln6NxKgSs9AB0uAzDoLCwMPXLk2VZqb8PLS0tbN68GZfLdcSBK/nY6fVbErhOPRKwxCkrVyG7UorGxkaam5sP2iNquB3NCFZnZyerVq2ioKBgSELhaC1yH0rpH7DJ9htVVVV0dHSwc+dONmzYkLFvXlFR0Qm5pc+pELCGIryYppmxxVP6itU9e/ZQX1+P2+3O+PvgdrsHDVyxWCxjW5+B+yhK4Dq5nXj/UggxBHJtdxMMBtFas3//fhYuXIjf7x+x6zuSESytNdu3b6ehoYHJkydTU1MzJB+mhwpYJyOlFCUlJZSUlACJFYrJ6cStW7cSCoUyVigmu4qPdhKwjs7AFavxeDwVuJIBfGCLEJfLlTNwJf/NSY5wKaUyAldylaI4eUjAEqeUXL2tlFK0tLSwbt06DMNg1qxZIxqu4PBHsGKxGGvXrqW7u3tY6sTSA9bArXJOhhGsgQZ+wDmdzox989K3cdmwYQPxeDxrheJo/JCUgDU0HA5HRgDPtYm5z+fLaBGSDFzpQTw9cEWj0VQgSwau9FWK4sQlAUucMgbb7mbTpk00Nzcza9YsNm/ePMJXmXA4I1hdXV2sWrUKv9/PokWLhrxW6ERp03A8pW/jMrDJ5Y4dOwAyViiOli19ToWANRKvb+Am5gN7svX19eH3+zM2rnY6nYcVuAzDwDRNnE5nakrxZP4enowkYIlTQnLUKn27m56eHlavXo3D4WDx4sV4vV4aGhqGfZPlw3GwESytNU1NTWzZsoVJkyZRW1s7LP/wnmpThEcaGJNNLvPy8hg7dmyq51JHRwf79u1j69atqRVpycDl8XiG6eoP7lQIWKNhqnZgT7ZoNJoKXFu3biUYDJKfn58RuJJTg4cTuAbWcJ3M39OTgQQscVIb2NsqOY2wc+dONm3aRE1NDZMmTUodT45qjbTBwk0sFmPdunV0dXVx+umnp4pxj+c1HOrcqSq951JNTQ22bWcVSHs8nlTYSk4fHQ+nQsAajQXjLpcrY4o5vQnuli1bCIfDWYErGZySgSv5c2bbNqFQiFWrVjFnzhxcLhcOhwOtNW1tbdTV1Y3Y6xS5ScASJ6309guQ+ACMx+OsX7+ejo4O5s+fn6qlSBotASvXFGFySjAvL29YpgQHkinCY5Psr1VUVERdXV1Gvc727dvp7e3F7/enAlcgEBi2FYon8mbPh2O0BqyB0pvgQmZNX3LXgYKCglTYSl9EYZomlmXR19eH0+lEa000GmXLli2cd955hEKhkXxpIgcJWOKkM7C3VXJKMNnZ3O/3s3jx4pwBZbQErPQpQq01O3bsYPPmzce1m/yhGo1KwDoyA+t1otHooB+uxcXFFBQUDFloOBVGsE7E15de0wdk7DqwZ88eYrFYahFFesF8+ibU4XB4xBfliNwkYImTSq5CdoBt27axdevWQ9YsjZaAlRzBisfjrFu3jo6ODhYsWJBaLn48nIpThMfzQ9rlclFRUUFFRQWQ+eG6du1aLMuisLCQ4uLijE2Kj8apELBGQw3WsfJ6vXi9Xqqrq3Nu85T8d62pqYn8/Hz8fj/BYHBIAtbf//53vve97/Hmm2/S3NzMU089xWWXXXbQ+7zyyit84QtfYP369YwbN47bbruNq6+++piv5WQhAUucNHL1topEIqxZs4ZQKHRYnc1HS8BSSmFZFq+//jper5dFixYN+wbTua7hVJoiHOnXM/DDta+vL2tLn/QVismO4ofjVAhYJ8IU4ZHItc1Ta2sr9fX19PT08Mwzz/Ctb32LmpoagsEgb7zxBvPnzz/qoNnX18ecOXO45ppreP/733/I2zc2NrJ06VKuv/56HnzwQV566SWuvfZaqqqqWLJkyVFdw8lGApY44SV7W8Xj8Ywpwb1797J27VpKSkqYN2/eYdW3jIaAlSxajcfjTJgwgbq6uhH7cEzvFXYq9MEaLZRS+P1+/H4/48aNy9ikuK2tjS1btqS2cEkGroMF8JMyYGkbiIGOg92F0+gCqxWlLSAOWIlzACoG2kocw077MkBF+x9L9x/TgEYrB4po/58HPLVyJe6XePD+r+T/d4GK9/9/I+2/BhonKN3/ZzPjvxoHShmgTRIfzcn/OgAnSvlwuVy4XC5mz57NjBkzOOuss7j33nt55ZVXeM973oPWmnPPPZcrr7ySZcuWHdHbedFFF3HRRRcd9u3vv/9+JkyYwA9+8AMApk+fzquvvsp///d/S8DqJwFLnNByTQlqramvr2fnzp3MmDGD6urqw/5wGemAlSzC37dvH0opJk6cOGLXcqq1aRjN0jcprq2tzdjCZdeuXWzcuDHV4DK5QjF9q6RhrVGyQmAHUXYE7BBKRxLHiKPs3sRxHQY7nDhnR8HQKLsbdLT/fBR0BG3mo3Qb6BBKR/uPx0FHsT1TMGKrSIYqReJnXuNkjKMOX0k97M28NNsoRjsDKHt71mXb5lgwIyi9N8e5iaD2o+jKPmdMArMNRU/WOa0moI12lM5xP6rAEQfVmn0/nQ9mCdpoyH5/tYmK3wb2+7EsK6Po/cwzz+TCCy+ku7ubP//5z6xatYqXX36Zrq7s5x9qK1as4IILLsg4tmTJEv793/992J/7RCEBS5ywcvW2CgaDrF69Gtu2j2q7m5EMWD09Pbz99tt4vV4WLFjAP//5zxG5jqRTbYrwRJK+hcvEiRMzGlym91tKBq6MgGUFUfEgWH2oeC9YIZTVB3YIw+pOnLeCqf9qZx5GZEfqNsoOJQKUMrC9pZihTVnXZ/lnY0Q2JkJSGm34sX3VmJH6rPvEPdMwY2+hdF/mfVBYvnmY0Vez7qONAmxXOT4r+/Fsxzi0EckdrhxTQe3Keq7EudnAFhSR7HPmbLSxuX9ka8C1qBlooxFF9mo+W9WB2QaqO/t+ugxMA3KGKw8q/l2UfT5ARsBKSq5GNU2TBQsWsGDBguzHGQYtLS2p+sGkiooKuru7CYVCeL3e43Ido5kELHHCSe9tlT6FtWfPHjZs2MCYMWOYMmXKUdUiGIaRGg07XrTW7Nq1i02bNjFhwgQmTpxIOBxObRg7UqNFUuQ+SsVDqFgPxPpQsW5UvBcz1kNVrIdqetFlBvTtIB7uwGruhh29vEOHsN9243DbuOOZIyjacGIXTMbRuzb7qQKn4ehah0pOtfWzXeVopzN3uMqfhxl6M+u47awAp5k7XOXNxYiuSY1Kpa5NubG9kzBjOR7PrEQ7XChrN5b2obXCNN2Age2oRBt9KG2jjTHotOk6bZaB0Qm6HK2Sx3XinFECqhPF+KyJQW2UoI0OoKb/nD7wpUrRxn6gov9ccgpSoykBsx3wgnZzYJrSQlMKZm9iVEur/unD5BMGULEfofTcA+9tjoAVDAbJy8vLen/EyJOAJU4otm0Tj8czpgQty2Ljxo20tbVx2mmnpZr6HY3jPYIVj8fZsGED+/bty+jLlb5J7EgGrKM5Jw6TFYNIFyrag4p1QbQb1f9FtAcV7QXTwOjdjor1Jo7HekHHsctmY3SsRg2IAVbJTMzejSgdI70iq1tV4HP04Ij3Ztw+bhaApwDngHClUViFc3D0vZV92b6JoDtR8SC2owSUC204AQfaU4GyO7G8s9EkWwkotOECwwbiaEc5oEFr0Da204/S7diuif31U8nw4UE7FYbVjDYK++upEtODtnMCSu3FsFsAMJNlULqPuHsuyl6PYceTLyZVIWW5F2DYKxNP0X8u+Xq1cz6G/ldWyZWNQjvnofgnuf7W28Z8lPpX7nNqDphrQGX/0qaZDOYOUGmjaNoAHKDHQOyHKDKbhx5sBOt4q6yspLU1M6y3trZSUFAgo1f9JGCJE0J6b6tk6FBK0d3dzerVq3G5XCxevPiYtyIxTTPV9X249fT0sGrVKtxuN4sWLcq49mSAGcnVUemjVAMD1ck4gnXMryfaB+EeVKQTFemCcBcq3AWRblQ8BHYfRk9zIkj1H9MuHwQqMLq2ZF6LIw8dqMQceNx0YxdOwuxYlXkchV02C0dX5nGAeOFM3L1bUaYb21GNNtxY2iBmm8RsjR0KAxNwOJ04+7diMVwOlN2D5Z2I0rFE3ZQdwfbVYoTXpab+lJ283gC2uxhH32tZz2/lzcaMrsueLlQuLN9kHJHXs+5jO8eijA6MWFv247lPQ9mbsh4PIO5ZgGFlh0KNge0+DcPOHgnTuNDOaSidfT8bF9o5FcXbOR9Tm7NRZN8PwDbngZH9fIn7zgZzXaL4Pp2ywR6Pit2HoiLrfrkCVnK/w+Nt4cKFPP/88xnHXnzxRRYuXHjcr2W0koAlRr2BhezJD/umpiY2b96cmlYbilGV4zWClSxMrq2tZeLEiVkhKn0Ea6QkQ5Rt2+zcuRPDMCgtLU1NR5xsASuL1hDuhmAHKtQFoU4IdUE0MZqketsg3I0KdUKkG5w+VL4fo6sp42HsvDKU08Dobc487q9AmbGscGX7KlCmToUrjQJHHtpdgJ1Xior1YgVmgNG/+swwUQ6NskNY+dPA7i8ctyLY+WMxu9/GoTTEgxDvSDxJwTRc4a0oHU7MkAFYELYKiMQc5Ef3Zb4VgBWYhxnMEULcY0BFMSNbs87F8+fjCOea3itCuwsxo+uyzlnuaSi9E2X3Zp2Le+djxN9Ojdwl/tfE1gYhNQWvtQlNfv+tTUCBcmK7xqLsnWjKOPCCFSgHtqMcpZvRVA54zSbaWQHsQVOeOpo6b44DGtEUQmpq00JjgzkN1KrkzOOAx50L5puZ04GpN2Y+KnYPioLscww+RZjc+/BY9Pb20tBwoA6ssbGRVatWUVxczPjx47n11lvZvXs3v/3tbwG4/vrruffee/nKV77CNddcw1//+lceffRRnnvuuWO+lpOFBCwxquXqbRWNRlP78Q11883hDliWZbFhwwba2tqYN29eqqv3QMmwONIBKx6P88YbbxCJRHC73Wzfvh2Hw5FqCZA8fiLR0TD0dUCwE/q6ULEeVPdeKlp3YoS7UWviEA2i/PkYezPrhXReMcrtRnXvzjhuF43BtLpRA8NVcR1GqAXV25sISs48tMuH9pWgTDsRXHwVoFSiVYDTi4q1gxXG9pSh4n0QD2F7izGsDhztOzMf31OG4TYxejKvR5se7IIaHN05pviK5mD2vJ09veirxaU78cQzw1VcO+g1xxAIvoWNEwx34ku5sJ0lYMRQWFjOEsBAKxO0Qrt8KB0i7l2AQiernNDKA0YYiGG5Z/a3SLBR2sZ2laHs3WhdhKaARKsFC4XGck/AsDYCbjSJVgwKja08hHQpPueG7O+1UYJ2eDHsHKNaqgLt0Bg6e3TKVuVoh2OQkatCtFmYc+TKxgNmLRhp57QCTDQmGDPB2AgE+tsxmIn/KhOsRSjrSygG/3kabARrKGqwVq5cyTvf+c7Un7/whS8AsGzZMpYvX05zczM7duxInZ8wYQLPPfccn//857nnnnsYO3Ysv/zlL6VFQxoJWGJUGqy3VXK7m4KCgkG3uzkWwxmwent7WbVqFU6n85DTmelThCMl2eiyqqqK6dOnY5ompmnS1dVFU1MT3d3dvPbaa+Tl5aW6jRcWFg7bfnqHoqMRdF8Hqqcd+jqhtwPd1wm9nSi3C/ZsSgSrWDhxB4cTVVmD0ZoIUckxA+0vwXAbqIHhqqQGFd6H6k4EEG04wZ2PLqxEEUErH3bBmMSAhbbB5UWF29CuvMQoRiyIivWiS2ow29eiyPze2mWzMPa/gdKZx63iGRi99Sg7c0rMKqjDjLeiQpkr02x3KbjdGH2N2M4iMNz0heN4fAFUXikq3oOdP6e/wBtAo00vSvcAHixXKdhxlI6iDRfaVORHd6K1wiAGdgzsXnodU8mLrs8uTDfzsT0VOILZ4cTyTMWw6nOsFATLNx8zmj3FqJUP21ODGV+Zdc42ytFODz57R/Y5cxyYIZRuynG/OjA6Ei0hBp5TtWhHN2pgzwdAU4U2bRTbs+9HABxFoAYEPZVYrIIxGcx/Zd0PBVgfQFm3ojh4OYBlWVn/5g3VFOH5559/0F/oli9fnvM+b7+d/X0WCRKwxKgz2HY3DQ0NNDY2MmXKFMaPHz8shdbDFbB2797Nhg0bGD9+PJMnTz5kXdVIjmBprdm+fTs7duzA5/Mxe/ZsgsEgcGAD476+PpRSzJgxg46ODtrb29m8eTORSCS1d1pyP71j/T5pbUNPF7qnA93TiQ72QM8+6N6fCFE9HYmRqOJyjJ4WdCR44M6GgRo7EbYOWO3mL8LwulCtmSEqmF9Jns9MFD2XTwHDkRhdcroSReaqCO1wQ6QXrAgUVeDYtybzeg0TXTYFs/WNzOOmE7t0Mmb76szjykSXTsXsOPA4GgMcPqziKajIXmx/DShnYjoQI3E9hLD1OLCt/mnBKLa7CCO2GxXajcJG9YdJFx6UmYezM7veKV44F0fv69kjWp6xQDeOSGbQ0CjC7un4rezpvbijHMNpYEa3ZJ8bdKWgE8s7bZCVgqWJNhHxjdnnHBPQRjfK3pl9zjkN2Am6r38F4YFGoNqcBqoJCCdGlTKuZTLasQsIZs3uaVWHNvahyG61YFOR+DRV27LOae0DcwwYq7LOAaj4jSjrupznBhpNRe7i0CRgiVHFtm2i0WjGqFU4HGbNmjVEIhHOOussCgpy1ycMhaEOWMkVjq2trcydO/ewayWSRfzHewQrHo+zdu1aurq6mDBhAp2dnTkDUvKY0+mkvLw8tXIzFArR3t5Oe3s7O3cmPvjSu40P3N5FWxa6uxPd3ZH46mpP/LmnE+VU6B1boLerfxoJVHEZSkUT4SqNUTsFtWdTom4qyetHBQLQug38xeDOA6cbnG4M0wY7jnZ6IB6BSB8hX4C8rkZU2E59sGrDhMrJGHsyP/y1y4sqqcHYN2D1nbsA/IWY+9cn/qxMcOWjXXno/BJUPIhVPItUHZBhoIwYxIPYeWMTLRjiQUBjB6pxtA8IaUphl8zC0fmPrO+JVTQTs29Doig9/bi3GjvSjSec+eGvlRM7MDXnSsG4fxpGrL/3Ff2BT7nRhgc7rw53bA+WWUui/kkRtzQR2yQetTBiFg7HZBwOV6Jg3jDRDk8iELrnkN4tHeVAmxqlQ9jOqYlz/VOG2iwC1QmE0UYliTonDdrCck1IjEzpCBovth3HUICysZ2zUaxHkXwfku0UwHLMQ7E2K+QB2OZctLEuOwCiQM1Eq21ADI2bZGf2xJTo2P42DFHQ5Rzo3m4m6sEMDYTAnpxxP3BA/CqUXpp1LYORNg0nFglYYlRITgkmVwkmw1VbWxtr166lvLyc+fPnD/v001AGrOSUoMPhYNGiRUe8dDnZlf54Sa5q9Hg8LFq0iL1799LR0ZHztoOtIvR6vYwZM4YxY8ZgWxY9e3bTvWsnfVs30925D180TJ4dxxUJYQZ7MYuL0Xt3QTSS/iA4SovRLZnTPsa4CbB/B8T6b+twgS8fs6IKIn0wZmriuG2BywV9+6B7L1hR6G2H3nbUuKmotvUo+8CHqDYdqMpa/G2Zo1zaUwD5AYy2xJSPBnDloX1FKL8fbUWxy2aglZHoEOBwoeLdqFgI7S2FWC8qHsZ2+zGsblRb5uux/VUoI4wRzqx5sj0l4HJhdmWO2miHDx0Yg6N7VeZxwC45DbN7Vf/Ktjy06QHDje0qRhkW4bDG6R+HofpH5wwHylSgI1j+2YlQo+OJFgieMoxII9pwAwp0GKXj2KYXXHk4gpmhzwSMvNPwxAaEOxusiEm3HkuhezsD2Y5KtENhRvdknbPc01F6E8oOZp2Lu+ej7MyRMNNI3m9+7nqrVBuGQVb8OeaDejtnqwWMuWiVPfIGYKtpYG4Dld1cVOsqcOwF1ZL9mMkGovr8nNczmNG0ilAcmgQsMeIG2+5m06ZN7Nq1i5kzZ1JdXX1crmWoAtaePXtYv379YU8J5nI8R7CS11tbW8ukSZNSI2gHvb5QiPju3dgdHdidndjt7ShlYe1oxO7qRHd3gW1TWFREsUuh9x+YatIKeopKCOzOXHmmyiow7DC6pwtKq1BuD5gOlNuRCC7FlRAOQqgHPD5Mt4LtmVNujJ2Eat6Y6DOVZDpQ1RMwWjLrY7Q3kBgVi/YRzB+LVibevDxwuFBWCOJhdEFVogVDpA8ClZjBnai27RmPY5dNxdy/CWVFs44b3Q3Zx0smYwSbUNEDH8wahZ1fC2YcpS2s/IlgOPtHeZwohwF2FCtwWiJE6hhojXZ7MENNaMODssOJDu1WH1bhaTh6E8Gg2AR6dyWe21MNRgwjOKDhKAZW4DQcvSuyvteWZzyKHoxodj2TlT8fM8dKQW0G0O5iCmPZ02ZBPRaX6sS0srebsTxzUVb2KJONwvbMz9mGwdaKqDkDd85w5cB2zswZrmwMtPO0nMXskOxx9dYgPa5OA3PtID2uJoCjDVSOLWt0QX8D0Xk5n/NgZIrwxCIBS4yYwXpb9fX1sXp14kNz0aJFx3X4+1gDlmVZbNq0iZaWFubMmXPMTU+HewTLtm02bdpEc3Nz1vUO7INlh0L0PPYEdns7ro79jGtvP1CN4jBxThiLvT0zMJnjx8P+ZnRPf2G5aUJ+Ac7KCgKhIHF/DbFYHDsaIe50kB/qQEVDKK2hrwvt8WKUlsD27RkVQqqqBqOnBToH1ltNguZ68BaA2wdOT6Jeye1ExcPoismJKcFoCLx+jFAbqn/kytf/MNo3FdW2FmVlTrXp6ukY+9dnFKFrQFfOxEybKtTKAS4/dnEtKtqBXTChv5arP2S7XIlC87wxKCuxb5+Kh7ADtRjdG7On+Aom4IjuRcUGFLO7isCbh9kzoBgfA7toJo6eHEXm/ikY8Z2o2IAic8OL5a/BzFWY7puGEd8N2NhmMaj+0IcT7a1G2fuw3NMTK+FQ/dOJjv5VeFEsc0Fi6lYptLaJ2g4sq4eeiAvbLsE0DBxOE4dpYniKMehAOyb3rztMbsCssB0BlN6PNsZzYJox0U+ruw/8vr1oXUlGF1HlxXYW9LdhyJye18qNdhQDzf1tGJK1WokNmLVRAaoFzTgyN21WaKMcjL3AJBLNQQ/cV1MAZjdoP9j90Sz5y4rOR1k3o3RmA9HDZdu2jGCdQCRgiRGR3O5m8+bNAKk+Vsli8HHjxjFlypTj3mTzWAJWX18fq1atwjCMo5oSHGi4R7DC4TBvv/02WmsWLlyIz+fLOJ8esKyWFvqW/xbD58Xe24YRDqduZxTkY+a7sXc0QqAQw+dDOd2oPDcqFoGySnQkhO7rw8jLAyuI3ZCoUXIADkNh1tbBzs0Zzx/y5uNyxDFat/c/kQm+fFR5FUY8BKXjDrQ3QANxaN+Z+P/BzsRXyRiMcBuqbcBIwpgpqH2bUfaBprIaCBbV4t+3Me2YApcfXTkBI9KBXTIZpUy0MkAplKlQsR7s/LGJZqL9wUUXlOHYO6Buy3CgyyZh7luVeRyFXTYTs2PASBxgFc/E7N2UHbryxqHoxgg1pa4dw4s28tAFY1HRfVi+Sf1ByKSru5f80goMoljOKSTrkhJbybhAhUGHsN01iaaiOobSESzfJMzQqtRoUqo2zcxHeypwhHI0FvVMRtnNqHD26FTcNx+P/QbK1KTXl9vapCs2nkJHjqajKh/bXYVh5RglU8VgOgjkNSXfzLRzpWgnGHp99mNShHb4UWRvD6Txoc3xKHKsWsQAczYY2a87cd/TwHw156gW9kRU/M6cDUQP13C2aRBDTwKWOO6So1bJbW9s2071h9q7d+8RFYMPtaMNWC0tLaxbt46xY8cOWTAczhGs/fv3s2rVKioqKlItGAZKBqzQGyvp+f1DmLXjoacbs7ycmG0TiUYpKC2C7nZ0X09ilKKrEx2JYFYUY29pyBh1Mmvr0C3bIZ4WFvL8mIX5sH8PlFSiXB5wOsHlxB3pxY6EiCgDIxrCwMbyevHuHLB6ragi0TCztz3z+sdMQe3bkhmiDAM1diqqpxUCY7EdLjAdaGUSigYxrTC6qBZiwcS0oOlA5eVhtmROL2lfMbjcGL0D+k95i8HtwuwYUM/lCoC/ALMj88Nemx7swhqM3kZsTwXa7O8xZTjA40fZYezATDQ6sY2MtrDd+RixFrDd2BQnpjLtMNqRh3I5MbsHBDsU2hyPqzdHYby3BmV3Y8Tbs+5j5c/BkXNPwUpwqJwrBS3faajYhrQC8+TjGVh5p2FGc4QkIx/tqqLQ2px1LhQLoF1uPFb2c9nmOFBhlJ09bamNcWhHCKVzrDBUVWiHztlqQVOENgtQZO+xaOMCcxIYuacTNfPA8UbOc9jzEtOCgzQQPVwDA1Y0GiUajcoI1iglAUscN+lTgslVgg6Hg66uLl5//XU8Hs+QbHdzLI50s+fkFNuePXuYPXt21u7yx2I4RrC01mzbto1t27Yxffp0xo4dO/iNbU3hyjfp7uzCUVGK3bAlFZgMQFWWYm/dCGnXaJSVYthR7N39Bd2GAXn5mGOqIRLEGFvb3/TIQrmd0LMX9jUnaoqCvWilMGonQtOazH+c8ovQTnB17sq4xEjJGNy9LWilUPml4PIlpgR9PpQVhopJ6Hg0MS1o24larj0HApoCdH4ZpkOT35tZk2QXjcW0OlHdA4rTC2sxovtQvQeK0zUKXTgeDI3Cxiqc3D8taCaK3404yo5iFU5N1GNZEbTpQhkxzK5EXVhyClCbbnRhLWb7P7O+JfGS03B0/SO7pUJeLYa1HyM8cCNnD3F/DaWh7DYHcf8MjGh/N/cB97F9E3CEDoTKxLO5sN01KDMR6GxnNRpH/9Sgie0sQ9GJdk3pnxLrn07DBKcXdBDLPT9RgKf6H1Q50aYGYljG/P53MvGMtuHDcPURj0foiRRgWYmg7HCYKLMIlxnCUPloo4yenh7yfD4M00AbxWB0ovCnTQsmnlOrQrTRA8lNmNOrq5QfrSIkurGfduB+qMTrNBSoKOj5me+XVmC6gT6wFvR3aE/7smtR1tcP2kD0cCQXAqX/8tbXlxgxlYA1OknAEsfFYL2turq62LdvH5MmTaKurm7ENxE+khGsYDDIqlWrgESt2MAptqG4lqEcwYrFYqxZs4be3t5DtruwurqxHvgtvo4OlMPAbu08cNLlgspifM27oCCA4ctLdDf3uFB2LDFC5XKjg30oBUaBF92QCDXJV2PWToTdm8FK2/fR48UoLYZdaaMHnjworsB0AigIlILW2PEYMdPA6GrG1jamFYeeCJbTi1lUjLFzQF1SoBJFGNWe2d5Bl03A6NuDCh+o5dIoqJiCEe9EOwqxfeUHaqhcbpTVh3ZVoONFibYKsSB24TjMrk0Zo2UAdskUzO76RNhLf3/zx2NY+xPb7KTf3lWE8uZhdg9YQahM7OJpueuqAjMxw42JqUZXef/Gyi60cqE9+ehYH/vitRQWFvUHn/7GovRim5NJdktHW2C4wIij4nsTbRJ0FHQUpWNYeVMwYvWoWH/BvpV8vwws/+ycewpqswjbVYAR2Z51znbWgurGiLVnnbNcM1D2ZpyEcPY3PE8KWlNwO1djEE+VWwX6f/Rs4zSUeiNrSjVxbibaeBtFJOucVhPRxs5BelyVJlasql3Z99P9o1pmdhhOvJAr+8PVsY9oa51oWJo+gpXsTzfU//aIoSEBSwy7wba7Wbt2LR0dHQQCASZOnDjSlwkcfsBKTgmOGTOGqVOnDkut2FBuqNzd3c3bb7+N3+9n0aJFOJ3OQW8b3bqN/b/4FaqoABwGRmEhqrg40T7D5UBFerE62gEF3V3Yvd046yZgb92QMa5iVFRBpBvdmjaNZhqYNROgpQnyC8HtTdRruZyg4okWDGVjIdQHoR6MijGo5npI727u8mKWlmO2ZU4bxfwlGDqE2TFgxKm8LtEKwXCii2vA4Uq0KXC5UXYI7RwLVpRosAczHsIsr8VoO1CboyDR9bxyenbzUKXQ5TNw7M9sNgpgVczC7FiTPdpUPA2jdwvYUbThRTt9YHjQLj/K5UbbMazC09Co/uc2wWGj7CBW3uQDmy9bYbS/pn/bGysxFmMlAoLlHYtBJ0Z3YnSs1AH0bj+wUjDHpsy2ewzYnRjRHBss++dhRLK319GGD9s7HjOyKvvxnGPAiGLEt2c/nnsGSjei7Oz2BnH3PJSdu1eV5ZyPx8y+DoD9wTqKAutynrMd89Aq92NqNRNtNOQMXjbjwNE7SLjKA7MCjOzvPYCK34Cyrus88uQAAQAASURBVM957mgkfzlND1h9fX34fL4R2xBeHJwELDFsButttX//ftasWUNhYSGTJ0+mrS37H/SRYppm6jfFXKNptm1TX1/P7t27mTVrFpWVlTkeZWgM1RRhcmPpurq6Q44S9r38N3r+8jKu8lJiWxvwAPHOTgDM8WPQu3eiI+EDfbHz8nAUF2BvTws7Pj9GVSXKiqH8FVBakZhGVAqlI9Da38uqM/GBpsZNgOZtEE9rZeBwYI4ZD3sGTG0FylCmBW3bwOUFjz8xLejNw2XYKGxs28KKhLGjIUIOD4H2rRnb0mjDxKiaiNGcWQ/kMJ1E/eU42zILn7XTC8VVmPsHHHe40YXjMLq2YnvLwOHpr6FygdeHskLYJf09pux4orGpN4DR15i4jY6j7BAqEsIqnIoZakQFM0e6bE85yqUw+jJ7RWllYAdm4OjJLsS2/FMwYjtR9sCVgm4sf13ulYLeyRjWbpSVucFyonXEHMzwgBo0HGhHEbarCCPegm2WASYoB2BimwVgWkAMzGJSK/CUQhv5KCOEZmrad6V/Ks70gQqhjTn9k4X9/dR1YtQNQmhzXsY5rW32dYUoLvEQtWYRi8UStZ2WjelwoJx5uJSNw3HagdV8qdfhASMCzOxftXjgjFaJ0Tx0Iegxiefrn/5LLCrwAJ39DUSttC8bZV2Lsq/Iep+PRa6AJS0aRjcJWGJYDNbbqqGhge3btzN16lTGjRtHS0vLEdU8Dbfkb4K5lkMHg0FWr16N1npYpgRzXcuxjGCld5E/2MbSAHY0Stfv/odI/WbMfC+xrQ0HTipwTKpFN20FXx5GoIK46SBkxSksyodYFKOiGh0KokNBzMoydFN9Wv/sxGiWivYkurKnPa5ROylzShAFhSUYRcXoWASqpyam5rSdmIYM7oNwBExnotVCNIQaPxXVfGDkQgHK4YLycXjaMguno6aHmNtLftuAKThfMXGlcEX2YfsrweFJjHSZLgy3A6wIVumMxBSgFQHDgSKC0bUFpe3EpsyQ2Hcwvwxj74AwZjiwiyfj2J+9F51VOhuzK3tvQstfi2HvQ4UzV0Bq04f2V+PoPbDqUGOA4cHKn4KKt2K7SkBVgnJg2YqevhAFxdUoO0g8bx6KxPbLCo12+FB2N7ajpn+qMI7CRmvQrnyM2C60WUii71biSzsr0WYYM1afes9T1+2ZjWFtyto7EcDyLsCMr2DgQJKNie05DcPKsRchTmzXtJz9r5LnyksS1+EwwW0mH9Mgoqfjdq1Kv8OB5zTmo1T2tCaArWb197jKnmrUegw4gqCy9ypMNBD9L5T9zuxzxyh9BiBJWjSMbhKwxJBLjlqlb3cTCoVYs2YNsViMs88+m/z8fCDx29iJELBaW1tZu3Yt1dXVTJ06Neequ6F2LCNYyfowpdQhW0bE9+6j/f5fopXGUVwAhsI5aRLxeJzevj6Ki/Kw2vclCtb7erH7elHjxuLf34LdfmBkRfnzMcuK0DsaMh7frK2DlkZwu6G4ItE81OlGeUxULIKumgCRUKKBaH4BRrADdmau4lLjp6B2rSJjKxyHC6NiLKp5QPNQXwDl80JbA9oTSGyR43CjXR6cThMzHiEUK8CKRtCxMHHTjV934Y52J4JCb6KuxS4ajyO8G9UxoP9UwViMaDsq0pl53FeGcoLRk9kLTDvyEoX0nZmrHxPtGeZihHZge6sThdKGE5SJ7fCiVBSb/MRoKjZoC62cGEYIZfViu8oTjUXtSKIBacGUnNveaGcFXlcYR8/2rHPx/LmYfa9lT/2Z+WhPGY4cU3+WZzJKN2PkaBIa983HiL2V/XgY2N45GPEcqxKVG9s9CcPKfi6t8tCOMRhWrnYKeWj3WEydvSeijRvtnISbDdn304rO3loKCwfp6m7MTawUVNm/3GgmgmMPqOzXfiwNRA/HYC0apP5q9JKAJYZMsrdVPJ4o9E2Gq9bWVtatW5ezJcCRrtobbukBK/nfzZs3pzrKV1VVHddrOZoRrL1797JmzRqqqqqYNm3aQeszwuvW0/XokziKCohtayCeFuhUaTGeaC/xxuYDdzANnLU12E1pIco0URWVGG4noDFqJieO2xbK44T9/fcP9iW+CktQsS5o3pfZPHT8JFTrtszCd4cDVTX+QIgyTPDkJ/YZLAhAPIqunpEIXnYcXB5UcG+iBxY6MfoT7kKX12F2bkXFQ5hAsgLNLp+M0bk1UZyfJlgwnrzgTpTOLlo3erclGoQC2kzUUGlvCcppoLGxPKWJlXVaJzqwqzBYYWz/BLDCiYJ3baPzK3F0ZgcOq/g0HF3/ygoptm8MhurDiA0o1FcGVuGsnOHK8tah7Da8ZAYCjcIuOA1HMEd3c2c5OEzM6Nasc3HvLIx4PYrM0SkNWL75qQ2bE1N4ielClAvLMwnD2p7oTaXS9uNTTmxnGeh92EYtaKN/OKx/Lz9HAehutDGFA+NkCpSBduaD7sJmCr29valf2kChHUVAB5qpHBi2svvPlRIobMWyarDsOJZlYdtxFBCnHI9vF4Yqw0g1ObWBOFqNB7MRCKZmLg+8AZWo2H0oPXy1pLJNzolHApYYEuntF+DA6Et9fT179uwZtF7JNM3jvqHxwSSH323bJhQKsWrVKmzbZuHChce9md+RjmClT8EeanshrTW9z/+J3j/9Bde4SmINmVNprom1WM1NOCwLo7gE7fag3C5MrxtiYezKMcR6e3DbFmZFBXpPI7o/GGkArw9HSSF6e2YhujFmPHTugb60WiOlMGqmQs8+KKkGhzsRpEwTpWKoaB8EyiHUC9EgePMwYh2oXZn9j3TVpMQ+gwM7sI+ZjrF3Q0YHdgC7ajrG3vWJaTLDSdzwYDnckF+BinXT5arGsm0cponTYWJ4/bjj7Wh3IfQ3FVVWCLuwBrNnS1ZIs/LHYdrtiTCZfj3OAPgKMHsGTFOisIpn4ejOrpGy8ydhxHelpiJT9zG82PnjcPSlTRdqlZguzKtD6Q4s/ARjXrx5gVRLBe0qAN2H5ZuXmlhVgG26MVQUiGE5SsnYfNlZjLKb0c4qtLaAeGJKERvbPQ4jvgGNE7D6pztjiZYPrnLM+IEglxwY0kY52lCpUJbxes1qtBnHyNEbSxvVaNPCsA+8fwE/iY4IqhztcKKoz74f+WizAkViKyAz8VcMnInpxLiehseVPRoGYOnZGOaazAai2gQcoCdD7IfH1ED0cEjAOvFIwBLHJFdvK6UUvb29rF69OtXVfLBh7NE2RaiUwjAM9u7dy5YtW6isrGTatGnHZUpwoCMZwYpGo6xevZpQKJQxBZuLHQrR+ZvfEd25E9f4SnQshrOuDvoL/E23ie7YB6aJEYtht+/HqKhAdXZg70qMhBiAUykcEyZg78gMUaqkHEOH0a07we0Frx88XpTfn1j2X1GTGKWKRcCyMDxO2DVgKqekEsPqhb7OzMeunoRq35YdosZOQ7VsSI36aIc3sVVO6ThUtAtdPjUxcqJJBAaniQrtB18xOtqLikcwtUXMX4y/K3NVmI5Br7+GvI4cxeFlszA71uZYKTgZI7gNZWeuTLO95SjTxggeCIdaOdCmF7twMirSgpU3qb8tRGIESDvcKBXFck1J1KIlpwsNE1QcI9aFbZYnFhDYEZSOEPdPwQgnVs0ZkGh1EG5DG3nY3qqcqwgtzyQc1p6s4niAuH8+ZiRHfZRyY3nrMGPZ7402S7CdXgyrIetcokloCGVnb/RsO+rQxn6Uzt7HzzbrwGxHkeOc6m8uSvZjakr6W1PkuBbcYE7AYeQOV109EykoytFcVFlgz0HF7jnmBqKHQwLWiUcCljhqg/W2Sq5aO5yNjkfbFKFt22itqa+vP66bTOdyuCNYXV1dvP322wQCARYtWoTDMfiPday5hc4HHkQ5DFQsRKzxQA8i5fPirCgivjmzzYGzrg57d2PG1J32eAn5fTjDQdTYCSjTkZi5cbugrwNCChzORG1VPIpROB6aBixnD5RimDa0ZXZDp7oOo2N75qpCQNXMQPXtg6KxaNMFhpFoMOowEgX0hdXoaBAivaA0Kj8fY8+AruZOHxSWYrQ2Zh2PegvwBzM3JtamE11cS8HAzuxAh2ssxR1rsJQb7fShHD6Uw4P2BFCEsAPT0u5gg8ONsjvAimB7Kvo3kw4l2kfkleHozO4CbhWdhqPnn9nTha5SlMPEiDZn3SdeOBczlGPqz1EIrnzMSPaokOWbgRHfgtI5pv788zAjuTqw+7HdFZix7Don21EFpoVhZbc3sB0TgX0onaPnlHMamiaUzm7fYDumgbEDRfa53lAV3oIuFNm1UZpqtBlFkeNayAdHKajctVoYp1FQlP3aATr3z6dr7y0UFloEAvawt0qQbXJOPBKwxFHJ1dsqFouxfv162tvbD7lqLSk5RThYW4TjKRwOpxqHzp49e1hbMByOQ41gaa3ZuXMn9fX1TJo0idra2oO+h6FVa+j8ze9w1Y5JrBJMe2yzvBRDR7F27QCnE8NfgO1y041FqcNAja1Fx6IQjWK4XOjgfvI721If+xow6ybBtrVkLNXy+TECftg9YJSrYjyqtw2iNgTKEi0XnC7weDDsCJTVghWFaARiYVRRKWr3gCJxlw+jqBjVtj3zuC+A4fWg9g8oNvcVg8vE6BgQrryFKK8bV7CDiLMYpze/P8A5weNBxcPES2YnVhD2fymvl+Ke7WArHDqSuM5oBx2eGopC2UHJDkzE6N2cCFXpz+0MoD1+zL4c284Uz8nZWNT2VIMK5exXFS+ai5mjriqsA7icboxoE1onVhyinGjDhe0eh9L7sZ1jSXT0TG5MbSQ2SqY30YEdSLZg1zj6m3/GsJzzIK1zuTbyQPWiiPc3Kz1Qy2Sb5SjVAjoAKp8DmzbbWI4aFI2AB42bVBdRbaOdk0Elvp8aL6T9zYvZE3F5tqNsG3BzYONl0Go82twPhND4084pNEX9r6ETdBmpujBUYqrTKAK1D+y6tHOJ87HIIsLd7ycY7GL37vXE43EKCwspKiqiqKiI/Pz8If/3TEawTjwSsMQRSfa2Su4hmAxXnZ2drF69Gp/Px+LFi3G7D29biOQ/GLnaIhxPycLwiooKQqHQYV//cDrYCJZlWaxfv559+/axYMECiouLB30crTU9z/6Rvj+/hLN2DFb7fhxjxqBcrsQ0oMcJfV3osI3y+hLtFsJBjDw3hc3NxPcdGCUxx4+HfbsOdPMGcDpwjBmLTu+e7vZCYTFGnjdR7D5uWiIsWnFUXh5q/47EiFg8Cl1hMAzU2DrUzlWZF+/OQxUWoVoGdGb3F2O4QLVvzzxeUIFBGILt6LzSxIiVw5Wo63IYKDuO7S0GO5YIcE43KtoOva2Y2sa0QhDtAE8RuJ0YnZkjRNrhgUAVZvvAFYEQL51BUVf2aregbwK+8LbsgnlXSSLwhTJHDDVgF8/F7NuM7Szt34zZjTacaNODcpooHSfuGUeq0lprtNON0j3Ynumg44l2CzpGTHuwrXZUvBuNA0Uc7P6Vkt65mJEcq/6UA8s3FUfo1azXYztKweHEiOSY3nPWofQ2lO7NOme5Z2HYb2XtUwhgueai9Fs5G4HarnnAmqw2FgC2eRoOYyNKxbPPGVPRZu4RL5tqcPTkbLWQaCBaCUZ2jzFINBB1G9dTXQ3V1WPRWtPX10dHRwcdHR1s374dpVQqbBUVFeHz+Y45cOUKWNIHa3STgCUO22BTgo2NjTQ0NBzWKMpAyX8wcv3jcTzYtk1DQwNNTU3MmDGDMWPG8Pe//31UFN4PNoLV19fH22+/jdPpZNGiRQfdu9EOh+l88BGsfftwlBcS35YYBbDb20GBe0od8fpNGaNZRkkJhrKxmzOnVIy6CdC8HfLysV0ugtE4BcUlKCcQDaPKx6LDfRDsxSgph47dsL9/tV3yMWonw/ZVmRfp9GCUlULzgA12/cUol4HavyPRzdybn2gq6slDuR1o24a80kQTUzuGdvswe3dDuDdRoxWLoNiPXVKD0bUTFQtmPLxdOA4juAsVzQwDdl45hoqi+gaEK2ceyl+I0Z1Zx6OVwi6dhrMzEa606UU7vNiGm7BZCFYPHXYVWhk4HC6cDgem24vDjIIdw8rzJ3pGWZHEHoX54zC7EiNXKt6XWqxm5dXiiO5ChXI0Aw3MwtG7goFsdzWmasNldDIwnySm/nK0dVAuLO9EzEiO9geOCrRDY1jZ4cpyTUGxM+f0nuWeg7LX5+7O7poHelXODuyWaz6K3Odssz94qRzBy5iFNutzhjlbTQBzL6jsKUqtC8HMAyO7SB5touJfz2ogqpTC7/fj9/sZN24ctm3T09NDR0cHe/fupaGhAafTmQpbxcXFR/ULXK5/I4PB4IiPtIvBScAShyVXb6tIJMLatWvp6+vjjDPOoLCw8Igfd2BbhOMpHA6zevVqYrEYCxcuTP0meCT7EQ6nXCNYyX5cY8eOZcqUKQet+4i37aX9vp8n9hLs7kD3HSheVk4nrpoq4tvS6nG8XszKSgxDoRToQCHdnV0UFvhRLgPdsjOxz2BXe6Jw2udHde6B3s7MLXJqJyWmBNNX7ZlmYgXh7gFNRQMlGIVFEAtDVbKpqE7s+RfpgGgQ7fKhokEIdqLzCjE6t6PiAzYorpiIuW9DVvG7XT4Jo3tbYoPl9OMlEzCCu7MeJ+wpxaP7Eu0fPCXoZHd2hxvcHpQVxS4uBGyUbSW6s3vcGKFmtNMP8SDKCqGsELpkFv6utAJ4DUQhFC9CR8OYKkdQKpqJ2bOagSx/HWZ8N8oODrhPoqO7GcxxH/cYlOrBtDqzz+XPy+rODolwZXvrMKO56qoqwGGh4vsSXc5xJgrxlSNRc2X0oilNbO6MeWCa0SwC1Yc2p/f/8nVgCs828sAIg56Hzvi9TKENH6ggmnlZ8UobeSgVBOYQiUaJRCKphR3ayEMbfcCs7PspLxghIMDAk1o7wbSBKNilyTv0nzXB/gjKPj/rfRnIMAwCgQCBQIDa2losy6Krq4uOjg52797Nxo0b8fl8GSNcB9u6KinXKL9MEY5uErDEQaX3tkrf7mbfvn2sWbOG4uLiQ+5tdzDJVXvHu9A9ef2lpaUsWLAgozB8tBTep49g2bbNli1b2LFjx2HVh0U21tP+i1/jHFNJvCnR5NMsK0d5PSiXG8NtQCSMWT0eOxjE7unBVT0Ga0cDVlqo8zidGPkO7KYBBcKVY3B37oHezKkZo3ZSYtsbfyF4fOB0JbqqO43+fQYnJDqwh4OJzZ11aEAnd6CiBtW5DRUbEKIqJ2G0b83aUFlXTcHYX5/VhkFXTsFor09sYeMOJLa8Md1otw+lLLRrEjq5jY0VJWgp3Pa+REiy44meVZBoy+B2YnS1ZD6+MtGlE3F05Ag3JbP6u7MPKE73VuJWIYzYwHAF3c4aAj059jTMqx0kXKn+cLUGjQtMD9rwoJUTbfrB6ULrfGKqgnAkRr4/kNh1xvShCBH3zE9cX7JGSmtspxPD7sJ2TAASXduVjmObAZQRRMU7E9FIx/rPg+WeimFvyVoxCRD3zMWwsov0ASz3Akz79ayRNQDLtQBDv5rV8R3Ads7H4NVUQHI7E1/oxKiWNrIbpwLYamZ/d/bsDvNajwdnB6iO7Cc8xgaipmlSXFycmsaPx+Op6cTGxkbWrVtHfn5+KmwVFhbmHM2Px+NZI18SsEY3CVhiULZtE4/Hs7a72bx5Mzt27GD69OmMGTPmmGsLjmerhvReUdOnT2fs2LFZtxlNI1haayKRCKtXryYajWaMtA2m7/9eI/jPN3DWjsNua020J+gLEu8L4qisQHfvw+pJW22lwDV5IlZj5uoyVVgE8T7slkS40spA+fMxyiqwYyF6/SUEAoHEFJ0VT2wps3cHWDHoaU985RWgPC7oHFCQXVqNEd4PkQEtAarrUB3bs0aiqJ6CsXdTIge48xLd2Z1edF4AZUewy6ejtEbrOCoeRfsDmO0NoFVi9CsaTPR5KpuEuW9tVkizA2PxxVox7QGhzl0IbgdGcGC4MtClEzG7BuyVyEHClaccjBBGtD2xtY2ZhzY9aOUm7q3CHd1LjzWRWNxCo3CYDky3D5cjDq6JKG0lAo+d2OzZ9lVgBjehbTMxFWbHUPRguypA7cXoSzQkNQGPAvrAyp+LI5hrOxoTyz8FRzg74NmOUpTRi2Hl2ATaNRmlt+fcKDnumYuyVg8argw7dyd1y7UApQfpsu5cgGKQc+Z8MN4i179GtjqtP1zl2OyZSeDYBSq7bmw4Gog6HA7KysooKysDIBKJpAJXfX09kUiEQCCQClwFBQWpf5MGjlhLwBrdJGCJLOm9rZKr+5RSqb34ko03h+oH+3gFrHA4zJo1a4hEIgftFTVamp8m3/PXX3+d4uJi5s+ff9AWDNq26X7kCYIr/omjuozYtsyVaa4JNVgtuyCjQN2Ja1wVVvNOjJIylMeHcvYPCVgRYvstvP4AdrAHgkHM0nL0jk0YQAGgO9vA6cYsL4FdAzp/B0oxiGWHq8pxGF17IJ6sz1KJ7uxl1Rh2GErrEj2eAGwr0UOruxntCkCkFxUOJkbAxk7DbM5cZacAXZU4nhVwyiZjdDXkDFdGfF9i25n099NVAG4XRnBALRYKXToVI7gD21PZv8GzGwxHok6LCFZgTmKKVFsoHUcrB0r1omJRNN7+LW56UbFe4iWn4e5O7FGYXk0XVaUY8V044zn6UgXm4OjN1YW9CO2ws7q9A1j+2RjhVVnHNQrLPx0zkh2utFmY2JIoV82VcwKKXSgdzjoXd5+GstYMS7hKDOoaJDvFaw3d4RryC7aCLiK1sXT/f7UaB+YuoKJ/yi8ZUhSaYjA7QZcmvjIUo2L/NewNRN1uN5WVlVRWVqK1JhQKpQLXrl27sG2bwsJCwuEwHo8nY8X1ULZp+MlPfsL3vvc9WlpamDNnDj/+8Y8588wzB7393XffzU9/+lN27NhBaWkpV155JXfeeedBa0JPNRKwRIaB290kw1VLSwvr1q0blr34jseI0f79+1m9ejUlJSWHDCqjYQRLa013dzft7e1MmzaN8ePHH3Sk0A6H6fj5r4nt3o1Z5Ce+48DKNJWXh3N8NSoaxjl+PCiVKBBHY1gRrObdEItihxLFyY6aGuwd2yAWww/YPSQ2Zp4wIXOlIIDXhxnIg7bMlXCUVKDsKFo5oGwcKtmd3eNCxYLoojEQC0G4L1GUXlKJatmIGlDUr8dOxdiZ4wN37FSMtuwibF05FWPfhuxwVToxd7jyV6JUFO0qIKQCYLpwe/NAOVAuldjk2VXYX4QeRcVD6IJqzPbEtKDiwKiHVTgJs/3NxEhT+jU58lB5+RjBAf2+gHjxaTi6V2Udt11FOJ02Riw7XO3TNZT25WrsmZdoXRHdmXWuh/H4I9nvC4Dln5O72N3wYbtKMKw2bKMY+uuutHKA8qGdDrT29neHPxBcEnVOUbTRXzulky0cbLQZADqwjen9xxOd4JW2sJ1VKLsJqOg/3v+lLWzndLBXo1H9qwmT5yEUn0lB/oasmiroH9Uys9tmJK5zFphv5xzVwp533BqIplNK4fP58Pl8jBkzJrHjQm9vanXijh072LNnD8888wxVVVW0t7cPScB65JFH+MIXvsD999/PWWedxd13382SJUuor6+nvLw86/YPPfQQX/3qV/n1r3/NokWL2Lx5M1dffTVKKX74wx8e8/WcLJQ+ms3OxEkpV28ry7LYuHEjra2tzJo1i4qKof9t7rXXXmPy5Mk5f5CPldaarVu30tjYyLRp0xg7duwhpzTffvttioqKqK2tHfLrORzxeJx169axd+9eioqKOP3/Z+/PoyTJ7vJ++HNjy32rfel979l6Ns1M9wA2MNoQAvHaxwJkCcs/sZmRAAkwmEVgDugnFh2xWi8YBBwbgS2LxcAr2YwQtnY008v03tP7VntlVe6ZEfe+f2RlVlbGvd1d3dVr1XPOHKkzMyJuZGZFPPl8n+/zffrpa79+Ns/cf/8LZLGAZYNqNFC1WttbFdm6Af9018iaXBbbATm7VOlwt2wluPxas+zXgm3hrF+PutwM4VReFKIJioEkOzLYLAkqIPBRjToiEkXkLzdH23RAjG5GTJ9bOmsQEOu2I8ZPhKMCRndijYfN1ozuxJo8EnpYDWzDKl0BN96MU7AjKMtp+sCoL5jSG+DXEH4VZbtYqoSoLvXdKMuBnhGs+TOhYwQDj+LM6Ezo67HqV0M+JCUcVHY9dimcIB5kH8YqHdYMWo5CohereiG0jZ96GLuydBspBYGIUI1uJCLmsOwownKbWVXCplqHhqyRTMZb6VALDQgB0s1gyfGFSIc6qPrCyJ8GQWwddv14aA3S7gVHIGQ44iBwtzU7CTUlw8DbAypcOm0+9ySWQbkKrlUWdJ4CcY2Soa0PCVViT/M5zUBngm9E+B9GcPejWjrxta99jXXr1hGNRvnoRz/KSy+9xMGDBxkaGuJbvuVb+OZv/ma+6Zu+6aa6Cp999lle97rX8du//dtA816wfv163vve9/KTP/mTode/+OKLHDt2jJdeeqn92Ac+8AG+8pWv8PnPh6M9VivWFKw1GLOtCoUCBw8exHEc9u3bRywWuy3Hv10lwlqtxqFDh25ofEwn7qaCVSwW2b9/P5FIhI0bN1KphFveO9G4fIXp3/wYVjqJnBrDr3Xc2BybyKZ1IXJlD/Qj6iXk7NLUa2f7NmR+CntgBNwIyrKZzefpHcihSvOoZE+TNFWrKMclQgN1ZinREX3DzYyr+tJ1i5FNiKmzzZJf5+PrtiEmdORqB2L8WDPwM5YGN9bs5IvGEdSRAw839xU0msdKZLBmTzX/XVmMNiA9iFXMI7qUIOUmEG4CUeoiV4Dq34I9GyZ2Qd9DWnIlo71YMq81eaveHdjz4WysILkZq3wCrDjSjjfLjCIKwmkGn8oSMtG3GJ+hApQTx5JTKHcDStYXyowVLFWjGt1EqqHxgzlZIpYiIWahSwwLEo/gVPSGcD+5B7t2IHw+IobyElj++dBz0hlBiInmyJ7udbi7QRkUNO/xlSdXzpNgmcjV4+DoVS2Cf4nw/wOCu5fJZ0IQBDiOQzab5ed//uf5+Z//edavX88HP/hBzpw5w6//+q/zzne+kwsXLjA6OnrD+63X67z88sv81E/9VPsxy7J44YUX+NKXwtEfAPv27eO//Jf/wle/+lWeeeYZzpw5w9/93d/xzne+85bP80HCGsFa5TBlW124cIETJ06wadMmtm7delvHQNyOrr3p6WkOHTpELpfjiSeeuGZJULeeu0Gwrl69yuHDh9m4cSPbt2/n3LlzlErhElELtVOnmf6d38MdGcC/eB463kPhunjrBvDPLagw0RhWMomVTmN5FkJmUP0SGg1ktYLTmyM43SQV7b04Nm4ygTzTRTaSaWxP4BSWrk30Djbn+3WTq6ENiJnzbXKlHK/pucr1Nf1JQ605gRJ8H2JxrPwFsD2EX4dCU2VT/RsRY4fDXYTZYaz82fB8wmgGS1TD5MqyIdOPlQ8rVOXMFpI6cpXehD0fVnOU8FCxDDQKyMQmsL1mKU3YKC+GkCWC1GMLCfCNZtnUchDBHPgBgsaSfK6gZw/OjCbPystiuQqrMRN6zs/sIV7WJL5jUwxc0mI8fD6RDc3RODpylTDkYyEIYpu0o3GUlQZbIqRm/I2zHrjQDDjtfs7djVBLCWiTU3pI9xHgAophwG3+1xpWbfWgRBF4nEql6QGLxZrzTpUdA1EC9Tit0uSCxNpcpzW+kM4egPAXnvfBfweWfHdojfcKunOwWgGnb3jDG9iyZQsAs7Oz5HK5Ze13amqKIAhC1YnBwUGOHw9/5wG++7u/m6mpKb7u676ubSv5gR/4Af7Df/gPyzyrBxtrBGsVQ0pJvV5folo1Gg0OHz5MPp/nySefpLe397avYyVN5Uopzpw5w5kzZ9i5cyfr169fdpfjnSZYUkpOnDjB5cuX2bNnT7tUeq1ROZVDh5n5/36cyJb1+GNXsfv6mqU51wXbwrYVqlzC6ulDFgpQqWL19CDHLiBrSxUGb8e2Nrlqw7ZxRkZIXlk6VoZ4AjtmQ35q6eOZHhA+Kp5GZAebcwgtG1wXGmVUdrQ5l7BSaI6VycSxxl9rKk6d6B3FGjsXyq1S6QFE8WqYXEXTWLKM8LtG0NgOIpVAzIXLbGpgJ/ZU2L9VjK8n0phEJjegrAjNqHi7SYisgMDZ2SyfBTXwm8RNZTdg58PlSpnZil04FI6OEA5kRrDKmvJaejf2vMZbJSyI5bAqmjJjfAt2JayQAcj0I6Qr4f01VAylCtiEzelBdCdWPazSNY/1BHZjURVSREDEUCKCjG5EyBmUvZvFcTsChYNybGAA1QyWANX0TymRQjGJYBClGkANVB2ooZztCA6F/GwoCJwnwPpiW6WMdwjrzbKgvkSlxB5wNM8pu6layX+p3e5eQTfBqtfr+L6/pNloueTqZvG5z32OX/7lX+Z3f/d3efbZZ3nttdf44R/+YX7xF3+Rn/3Zn70ja7gfsEawViFaJcFWl2CLXM3OznLw4EFSqRTPP/88nufdkfWsVImwXq9z8OBBKpUKzz77LOn0zRlU7yTBas0/DIKAffv2EY/H28+ZRuWU/+kVCv+/vyeyYwv10681VahiU6UR0SheX5rG2NLON2dkGDk70SQ3HfC2byM422VctwTOhnXIi6ebakI8CdE4vu0QyaUhCJDxHMV8nlTUQwgQQRFmm+W2NiVM57BUvUmqOpHuwapMhclVModVz4fJVSSBEA1Eo4tEWTYilULkwySKwa0wfxGZHGnmYNmRZvnNjWIFJYLs7uaoHL/WNN17MWK1MWxZh8p8++athIXoWYc1fzZ0CNn/MHZe03nnZbEa4yFyBRD07sKZ15QZI31YtXDZDUDmHtV2DConiVD50AgeAD/5CLaGXCll0Yhuxg6uUAz6CaSDZUewnQi2E8eyXYT1+EI+1gIZUg2U14Pln0fRj5AVUFUs6kAdP/4ETvWr4XXjoGKbsRthYiitHnAmsGS421Ham8E6o099tx9BWYf0UQz2E1rPlVKA/RjYmtE3Korw/1+E/EbNHu8tdBOsYrHpcbzVbu6+vj5s22Z8fKnSOT4+bvRz/ezP/izvfOc7ec973gM0Z7eWSiW+7/u+j5/+6Z++7YOv7xesEaxVBlNJ8PTp05w5c4bt27ezcePGOzp4eSVKhDMzMxw8eJBsNsvevXtvOvh0pdZzI2h1Nvb39/PQQw+FOjN1Clbpy//E7Mf/lMiOTdSPL/XciEgEry9N0EWu7KEh1NxUiFy527Yj56awhjcgXA9l26DAijio+RlI9iILc1ilMrJcwc9miJy5jKLZM5YCqHmInjTkuwIavSiWa8FcF7nyYlguMN9V+nRcrJiH6FLGlACR7UNMn2kGhUZSTT+WHYFEEhoVZP/Di3MNG1XI9CHGFoZOlxeIJ6DSw9i1iTCBs11ELIIlNQGUg7uxpzXZUMkRrPmw50kBKtmLVTgZei7Ibsee1xAyBCqSwiqHc6Zkcht28cDia5UFdhxlJwgSm7CCWQJ3qGlob3XxWS5CVZDuQyAb+PUiQlZxrToytZN4pUnWIixsoprCUaExTNrXzRccQDQu6ecLRh/Fbhh8ULHHsAJd6dJBuTmEPB16TolesOcRGnVNWttQ9intTMJKYxcRr2sdMooiAda25szB4JFm8ryyaY4q8CD4AYTao13/vYRWdE7nNaJcLiOEuGVvrOd5PPXUU7z00ku87W1vA5qq+ksvvcSLL76o3aZcLodIVGtta31zi1gjWKsInapVK36hlQ1VrVZ55plnmsGRdxi3omAppTh79iynT59mx44d140zuBFYlkWjEZ5htlLoXPO1Ohu7FazyV77G7B/+VyI7N9N4balxXTgO3mCO4MpCFEA8gZVMIhKJZgBoOgmBbHYYVipY2TT+2VMLP+8XfT3e9m0EpxZLTu1L6MgoiYmlCotCUUrESc8sDeFEgNU/AOPnQudkDQzA+OKNVblRiCYR/SOoahE19FBzB1I2Fa54EmbOo1QUUalDZUHxGN6GdUGjVmQGEdPHNZ15LsLyQ+QKQA1sx54Kl9lkbhPWtCYKwnIQtkTUNHPu+h7BmQsrVMpJIBoT7XUpbJSTAjtOkFiHFczjJx9DtPObVJPIijrS3giyivDLEJQQjQoyuxU3/5XwcRDI1Gbs6qJq1LolB+4oVjV8PgBB6knStfD7KZWgikdMhX1c0hnUkiRo5mDpyBWAjDyKJTXqGh7KyyDUolrYvFcnUVY/0o6A2kLTj+XQep/migGReAnkNqAKlIEighrK2aEvGapBhP+fVjRA9HaidX3sJFitDKyV+DH8/ve/n+/5nu/h6aef5plnnuGjH/0opVKJd7+76Ul717vexejoKB/60IcAeOtb38pHPvIRnnjiiXaJ8Gd/9md561vfesMRPlJK43XvQcEawVoFaJkQjx07RiaTYXBwECEEk5OTvPrqq/T19V03G+p24mY9WPV6nVdffZVisbii5PB2lggbjQavvvoq8/Pz111zp4JVeeUgM3/4X/G2b8IfH8MeHMKKRsFxUEJguwJVLEKmt+m5KlZAOFj1Ko25/JL92sPDyMtnFzvUFuBs3kxwTmPk3rAJ92r4RlrI9pMtjYUer/StI5afhOwgwouD3fRjWZEIqjoP2Y2LfqxKHXp7EGc1vp/+DYhLB8PZWMkc1ly4nKYsG+GKJhHrxsA2rEnN8OKeLVgaP5ayPUQwr1VLVN8u7I7xOAob3BQy0gOyjp96uKmUtOQhGaAiUezqBNLyEI0SIigj6gVkPIEzux+hwmQtyD2KXdDMBPSy2DU9sQkyj+FoDO8KAa6DqIffmyCyAbseVtYAatGHiREmnwqBdJPYfvjzl/YAgnADgVI20n0MISeRYgcCj1ZYaHNMTwwh8yi1ZWFgdAmhiigCcHxsqXkvrG0kM+exLA3ZNZUF5RZE42O3PUB0JaEjWMViccXCnt/+9rczOTnJz/3czzE2Nsbjjz/Opz/96bbx/cKFC0sUq5/5mZ9BCMHP/MzPcPnyZfr7+3nrW9/KL/3SL93wMVdDGXGNYD3gaGVbSSkplUpEIhGUUpw4cYKLFy/y0EMPLaul93bAtm1qtXBr97XQ8otlMplbmoWow+0iWIVCgf379xOPx9m3b991PW6tUTnV46fI/9X/wtuxjcZrrzU9UPnFElt05yYaJ5becIXrYicjBBNLlQcrk0FU5lD+0huSPTCI0ihOpVSG9FhTUVAIiCcR0QQqlYb8DGpkV7Mu5vuoWhU/GiE6ebbp3ylV2jqS7BnEGhsPxTSQ7m12GHbDjSFqc2FyBYhkEjEdNokzvAOhI1G5jdi63CzbQ/iz4VBS4aD6d2NVJwnSO8BqhmsKtbBNY54gtgX8CqJebCpLjQJEB7CnT4WOI7NbcaZ1JAVUJIpV0pCr5BYszVxCAJUYRpQ05+n2YVf1XV8FdzspTaaVwkI4FqKuISjeOiLo9zdd30JaXMKnF6wkth1H2BFQNsqJICijVKOZ8q5KCFkAK4EVnESocGdsENmDHYRH+EgEKrIVgaaRgCGUM4EldORqz9IoBunQTHLfgfD/4x0PEL1VBEHQntvaQrlcXtExOS+++KKxJPi5z31uyb8dx+GDH/wgH/zgB2/qWJ/97GfZv38/AwMDRCKRdrhqLBYjFosRjUbb/+t5HpFIBM/z7poIcLO4v1a7hmUjCIJ2cKjjOFQqFb785S8DzSyTlRqzcCtYjudJKcW5c+c4deoUO3bsuC1+sdtBsC5fvszRo0fZvHkzW7duvaE1W5aFPT3L5H/9a9zeHI3Tp5dEMQBEdm2hcTp8U3fXDzeHPHfCsbGTEeTE0lZ/EY0hHAmpHIHlUqw38CIx4skkcnqMIDMMlTKUijBXBt/CrhRIV0pNb1cLsTiez0KI5SKkbRPU5nG7yZUAEY8gpsN+GzG4HjEWvrmL0Z1YExqylBlCTGsIhGVjqTLKjaPcFDixZpCncCASA7+IdPrBr+GX57GDCiLRiz12GKHkEjO1AkTfeq3hPejdhTOniS8QNkLOhR4HCHoewilqiJewENT0mVGpHTgacgWg4v1aH1ddZIiL8JoBZEeKuxIJlJVGWQkggvKyoAZAqWY3n6whVAUlIvRGLi7kXdUgmGlne8yrnaQ8TakRgfRGsYIwMZb2EBD2rAEo70kEOh9XHOXZIOY7Xwz0I611QBX8p4EKiBlgGtQuRPChey5A9EbQbXCHZomwsynmfsLv/u7v8qlPfSr0uBCiTaha/8ViMSKRCOl0mnw+z0c+8hHe8IY33IVVLx9rBOsBR+tXT8tvdfXqVTZs2MDOnTvvGYn2RkuErZJgoVDgmWeeIZvN3pb1rKTJXUrJsWPH2rJ7a8DrDaFUpu9/fwErFkXOzzQzojrgbl6PfybcoeXt2Ip/unnDUsLCSqYQiQROXw7qNezNaZQfoBp1VLmMnUsRXFgs6SShaW/ZsJ7UfLjLy+nNoq6GVServx80pURn/Rbcy2HyU8gMkZnWdAD2b9CSKxVNYeUXiYJ0FkzvThzSOVSQa7riF4ZP06hCqhdrvJWd1TwXAajUAGJmYknsQ1tPjDiIqqY02L8Le07nyXKxqmGPEoDs240zdyC8jR3FqoVH5wDI7MPYBY2PCwuLcM4UQJDYjl1eSjyVslFOhooYwZFFIrE0zXKcQMgAJQTU80jZhwgKCFVG0Mzk8pN7cIphRan53A6sro5OAF/0knDCpUGAIPo4dnAgfK5YKDeOULpS4zYQS1U8pTwU/ShnE6gKyH7KpSmi0QqWNYuye8H+UjihPfj/IORP3ZMBojcCHcFayRLhncYHPvABvumbvolGo8Hc3Bzz8/PMz89TKBSYn5+nWCy2/yuXy0xPT3PhwgXm5+eZnZ29/gHuEawRrAccLbJw7Ngx8vk8fX197N69+24vawluxOSez+c5cOAA6XT6hsprt4KVUrAqlQoHDhxAKbXsJHzlB9T/y6ewKlXsVJRgrrzkebsni5qbxsrmmsGcXgQsC+F5qGoJ0T+KKpVQxSJBvojb00vjaJgceNu2EpwLqwfOlm3I8ydCj9ubtqIuh19vrdsEV8NkT/SPIC6H96PiKVI1jZrR8i2lRxe6BZvhkkpKRDRCUJwCKlAtIMp1KM/CSB/WhQPhY8QyWNXJUHYWAPEEohp+vJLZSGJO4x+yXUTtauhxANm7E2dW0x3oJrBLYXURIMjtwNFlXtlRrIohriH7CHb5ENLuQdkplBUH0SzLYdnNUTRBHRGUEH4B/ALK6SVTXyBeXfYrP/sodkVzrlYS2z+nXYOfeBS7oS9ditgQVmMq9HglyDTDSTXcRkbDKe5KxVBiAGn3IlQGpSRClUFNI9QMyhtA8AVa9rjEgogj7Z0o91CIXIng+xHy+7Vrvl9gUrDuV4K1d+9e9u7de1Pb3k9dimsE6wFHoVDgn/7pn/A8jw0bNtzW7ribxbUIllKK8+fPc+rUKbZt28amTZtue5fJSgSfTk5OcujQIYaGhti9e/ey1cL8p/4OOVegOtRLPJ7ASudQUqEaPrJaQ3jgX84vvLpZghKxKE7CQc4tLUlZqRRqKkwOrEyW4Mo57ePyavhx4kmYCg8SxvWgqPFECbCsAFAoYTfT26MJlBNDpJJQryKlQjUayFoFVS5STWVIjV0IF8d6R2BC0x3ouFgaoz2AyA0hJsJRCrJ3I/ZMmPgoBG6Q1+5L9e9oD3heevwEdiFMLAFkbjNO/kB4GzeJXVpKOpWdQNkZguQGLL8AkS0LAeSymdcV1BGlSVTVRjCP6FCyguzDOHl9VAK2As2ffBAZxTIFlCa3Y1c1uVvC0ypNzf3txmroS5ducgNWsPQ53/eoySEsUcWxH8cSIFQJEUxjqRn8eA+2H87WCpwdKOtgKAfLl0OI6Pnm4GYZA7YgVAzktyH4Vu267id0RzTAYhfh/QgpZZsodf6vlBLHcdpVFx3upy7DNYL1gMNxHEZHR9m8eTPnz5+/7my7uwFTSa6z4+7pp5++YynFt6JgdQ6XvtkGgvIrh5n7289hb15H/MJFqixVBaK7N9M4FSYIkfWDNM6GFQlnIENw4Vx4rYkIYiJcArSyaeRlzeP9vXBl6f6VEljrN6OKs5DoBdttdtVJiYjF8PPjYC3MMKyUgBJiYAQxdmgJVbIAInFS1bACAlDxqyQ0niQxtAUxrvFkpfqxJvW+HqExRQOU0htIVzWKjhPFKuhLXyq3GUunXnlprPnjSCeLclIoOwHCa+ZVReKI2mwz66leQtTnm3MMnTJO7SjC15jAex/FKuhyoywsX1+eDFI7sathggmgYmmsSrg8K51erFr4/YTm7MLOJPf2vrCWeqHajycI3B2gAqT1JEL5CFmCYBpPztKwbGLqKN0TdHx3F0IdCK+NNMqZDXV2NhoxZCSHI4cQFIEzwGmQv4Tg3g8QvRH4vq8lWDc6X/Vew/V+cLbuU7ZtY1lW+7/7DWsE6wFHPB5vz6m6XUOVbxU6xWhubo4DBw6QTCZve0mwG6YE9euhXq9z6NAhyuXyTSfJ+/l5pv7wv2HnMqjx8I3THRlomt27H9+0TkuuvK2bCC6EFRZ/aIjIRNgD5KzfiLzc3I9yPWqWRySdxUomUdKHkV1N/1atRm1uFi8RR5050/Q8LVmQhx13oFwIHcMyXHXE0Chc0YR3DqwnkT8Xelw6HtZs+HEAkcwhKprspv4t2Pkw8VJCEA3Cc/4AVN9WrA71SioBbgoVyUIg8dOPATZIteD9qkA8hzV9qO1raifDuwmE3UAE4R86MrdV79eyPETVYFLPPIRT1o+2Qeg7c4PYBqyKnkSp+HqsqqZ0acWxAo3qJ5IEkYdBVQisIYT0EUER4U8j5DyWPYXVCKueQeRRYiqseAXSoRaMEdV8R1RkE2IhMkKpHEJtQClFWU6RcjvOR6VBfgTBE9pzvB/xoClYOkxPT/PFL36RAwcOUC6XUUrheR6JRIJ4PE40GkUpxTve8Y775rzXCNYqgm3b+L7Gj3KX0Un8lFJcuHCBkydPsnXrVjZv3nzHJeGbKRHOzc2xf/9+0un0LSXJT//RJ5GFEpHNIzQu5Jc+6VgIVW+auDsgXBeKXa8FhOc1x+N0QdoWqlKEngGsaAIcD4TVLEGKBio9jCoWUaUKLlVkYQwxMoiaWFpm9AAx2A+F8DHs9RvhoqYLcHgDTGrIQiyBmNBnOzXLjGGUk/2kS5o8rGQf1pRBveo2IrW2GdiBN3uUwIpApAfcBFjR5uzAhkLGHkE0alAvQnUeUaqhhnuxxzRdgE4U4Y9rR9jI3GacWU2p0Y5gl/TnL3M7sAsHwtsAVqBX/ILkDmNkg4oksCphNVA6PVr1SokUfuxRhCyCcJskyi8i/CmErGDJ09p1BIk9WFpjuwNiAo0giUrsIUq4PDlf34IrStjWYzhiBktdBGbwo0+Sil/q2PmjoH4Wwf0RIHqjMHmw7kYw9O3A3NwcP/ETP8HHP/5xUqkUhULzh5nrum1bS+s+8da3vnWNYK3h3oPjOPesgtVKmW8Nmr6TJcFuLKdEqJTi0qVLHD9+/JYJYfHL+6nsP0J05ybqr4VJSHT7Rm1p0Nu6Hn8hqqHZNZhExJM4/TlUrYroHUE1AvxKldrcHOTSxMav4FMGFjtyvO1b8M9pSmHr1qPGwkSmEk8S13i48KIwoTdqWwaCIwZGtOoVgxsRMzrTuUMq0HcTFa0Ime6oCGxU7yZEUCXI7WqW65TVzOVq1BEVRb2Sas4iLMzQTrcf2ok1rSEdlo1V1PjRANW7FUtHoiwHu3ROu43MbdfOKFSAaBg6FDO7cAxKFLbeCCwjQ1gVXZxEGhnd3ZwpqRyQAcIvYdUnEaqB4x9uZll1wU/twW7ogk1tBIYuyehj2iR3aQ0ATVVLKQFsBJVDNqrEIldwrLnWzgGoqa1Y9isIQAabsNiC4MfgPgoQvVG0onY6USqV7nqG4Urhd37nd/j4xz/OD/3QD/Gv//W/5vWvfz1vectb+PZv/3a++MUv8sd//Md8/dd/Pd/2bd+2vE7su4w1gvWAo/Nmf6+WCFserC9+8YskEok7OmjatJ4bIVhBEHD06FEmJyd58skn6e3tveljykqV2T/9K6x4FP9q+IZqZ5I0Ll1CZLJY8QQiEgHLQbgOQa0CvesJSmVkoQhTFeyMgz91CrqaGpxoFC8/HRIPhOshJ8NGeIXCqoU9QQAyYiPq4Ru5PboOLoU7B8XwBpjSqFduFKFTtVgIRNc9PrQFMdEkCtKOQCSL8hJIEcFRkjlvK0G9hh008IIGTqMMGQd7atGk3S7b9W3EmtZ7rKjrSZzq346Y1ak9AlENz/MDkD3bcTQxDwBWQ9MkAMjszlD8QgtC6NXoIDqKXQm//9LKEkQ3I/x+UC5IH9EoYdWmECic+sHmIOcu+JnHsTVjdJoZX3qSKZOP6ucQihhCGZQ6b3PTiyYDbP/8wsicszSST+KwtHHDl0lkbIxauQe/lsR1o9RqL5JO93GDk1ruKwRBEArZvJ+7CLvxR3/0Rzz55JP81m/9FgDVapVt27bxnd/5nXznd34n3/Zt38ab3vQmfuiHfui+Chu9f1a6hluG4zj3XIlQKcX4+DhBELBu3Tq2bNly17tEboRglctl9u/fj23b7Nu3j2g0ekvHzP/1Syjbwdu4HlkuY1sOgR8wN5Mn5UWxeuLUTpwB1TSKtxDbtYH66bBa5A730DgdJgexjSNttWvJ6zevJzgbvilXc30kZsM3f9HTS3Jeo6w4LkxdCj8OWAZVRQyvh6sa9So7gMqPoZJDKC8BVgSwUVIhapLA2dgct1Ms0+yknENs2Elk7GgoSrLuxfGm9CRKuPrLoOzdiD1vKFsG4cHHAKpnC3Yh/D5eaxuZ3Ypd1pc0MZRHZXQIS7ONtHPI6EaU3ws4EPjUCtNE1DyWJXBqhxAyHOzq5/bglHWdgxYi0GSVATLxEJavz+tCGSItog9hBQvBpmRQYgMisEAonGp4tmLgbAA0HrPEQ7hUcSNHmCoMcfnyjzI7e4lG4yyZTIaenh56enpIJpN3/XqyEnjQYho6oZTi4sWL/MiP/AiwGI7dmmQB8MILL/CGN7yBX/3VX+XNb37zXVzt8rBGsFYBWl/Ue03B8n2fw4cPMzPTLMfcDb+VDtcjWBMTExw6dIjR0dEVCWxtjM8w/T+/hJNLUjr4GgSLx44CatBdIFddswMHe6mfORfan92TpXE2rAhZiTj+RU3pzrG16hWArfQlPSuTRmkIlr1uA2hyssj1wXjXsGgvjoymsZWDHHi4WbIL1MJA6jK2l4WJGZplzA6yOLgeMXMufAwBYl4fI+ANrccaCytBdTdOZFofsyAMKqpMD+PM60ugphxLmRrFLp7TP+no/Xoy0otVNJCo2GaUP4BSDvh+c2RPdQpQ2LVXl5joW1nfQeZRnNKB0P4UAquhL+cFyV3YDX2cA0KfUC/jD2PJcGelVAmQCqWeRPhTWI0LCJqv81MPIzSXJhlNLOkaVKof6ewEvowgQMp/zuHDL/D1X/8otm1TLpeZnZ1lZmaGc+fOYVkWuVyOnp4ecrncsrLo7iUEQRBS9R8Uk3ulUsF1XSKR5s+iWq1GNBqlWCy27wdSSrZs2cJ/+2//7W4uddlYI1irCC0PllLqrhOZ+fl5Dhw4QCwW47nnnuP//J//g5TynmjFbQ1Z7n6flFKcOnWK8+fP88gjjzA8PLwix5v+7/8LggC3J0VtJqw6Oekojemw+uNk4zRmwo+7/RkahbDp2Fs33E54X/L45o3asFF7ZJTohKYEFIujdDlZAOU8ACoSh2i6qTzZHiIeoxHphXodVamgSgUo1rHXZfBf0xAc1wNfX56zPEMDweBmhIYsKQHWvKFslxlEzGm2ceOIWb16JRJZqIZVOhXJYM3pg0VVLAvVsBKk3ESIREklUF4vMrkN0RhpeqIaDagXEZVpUD5W9UQzTLQLQd/DOEV9V6FuTA2ATG3HruvjHLD0BDuIbcNqmFS3EgQLqevWZpAprNocRDI4pfDwZeltwQrCvrDA241YmIWo6EME67CCc8jY4eboHr4RP/g5lPpqOzcpkUiQSCRYt24dUkoKhQIzMzNcvXqVEydOEI1G2+pWNptd0RmmtxMPsoLl+z4bNmzg/Pnmj5ZGo8H69et5+eXFsnSpVOLo0aP3XSzFGsFaRWj9gerq+XcKnabw1ly+lgx8N9fViRbJ62yNrtfrHDx4kGq1yt69e1fswla7MEbhi4dwh3qpnQ6TmXoqin0u/Ljdl6VxNqyi2OkU9fPnQkGMwnUJrhhM2ZoORAAr6qLTO63hUdT8DIW6JJbMYtseKpCIiEcwPY6qZaBYp1W2w3WxIwpq4dIUlr5saI2sg6uaUls0ru9CBCzH8KOhfyMirydLsUA/embWSdPra7KdLBurcE67jcqOYs2G88OUsEPqlVQWyutDpjcj/Eozjb1Rh1oBUZmBoISoncfS5ILJ3p1YRb0vy5L686lF1xGt6lU35dihlHcAGR3GrunLncqLQlcKhFIOQeQRhO+g6i5W7TxCNcmrBIjozecyktBWQqVXA9WLkBuwG68imKSefhI4AOqfgfglgoV4EN0PRsuyyGQyZDIZNm/ejO/7zM7OMjs7y+nTp6lUKqRSqTbhSqfT98QPPB0eZILlui5PP/00X/lKs0QciUT4ju/4Dj784Q/zkz/5k7z+9a/n7/7u7/jc5z7Hv/k3/+buLnaZuPt3szXcdnSWCKH5i+FuEBnf9zly5AjT09NLTOFCCIQQ90z5sptgtcb0ZLNZnnjiiRV972b+6nOgFE46RjARJhsq7oCmpd7rz1CfC9/MG9k47tWw8uNtWkdwNqzUOOtGkZ2lOzeKSKYhkSKQDnOpdUS9KLZUBKUyqljCuTyLmpsnAsiJYruA427diJoNZ0nZ60bhkmaMTjINmu5EANHQG+vFwChc1cQPeDGYOqffxtN/XqpnHVZBf/xs3EI39q+eHCFWNRynsfR9lzhNEpUcRcgG2BaqUUdUC1CeQcgiQs1gacqNMrsRu6wnhUZfVnwQu2zIy3ITIUIEoJy01hAPIKMD2Dqlzk5h1Y83Zx3am0HlEPUKVuU8yra0KfAysTuU5g4gnWGERr3yvUcRgYPVuIRYiG0I3E0gDkLwAti/DEKgVOOaqd+dcByH/v7+dhdatVplZmaG2dlZXn31VaSUZLPZNuGKx+N3Xelv4UGbRdiJaDTK937v97Jjxw7K5TLxeJwf/MEf5DOf+Qwf+chH+JVf+RUAnnrqKT70oQ/d5dUuD2sEaxWhlYZ7N4hMoVDgwIEDRCIRnn/++Xa9vYV7yR/WIli+73PlyhVOnjzJ9u3b2bhx44pecOvj0xS//CpOX4bamfCNzM4lic2EfS5WPErjfFiNUpbAmtHnIlGcBzfSJDUL2VdK2MiYh+yNIMtVgvkCqlCDmSLRXQM0jp8kQrMrvtUaYa8bQY1plLBIFHlVr5CJRkUXeYQ1MAAXNWXAdNZolBd1A/EaXKcfEO16WDq/FiBiSQhX2VDxHNa8/lwaStLp4gmEh4r0oaL9CKXwo/1Qr0NlHsqzCFWAER8x1SQxnd8eFe/BNnm5onEohx9WXhKrYChDJgdgPuylklhEGvrjBKlNOGVdzIJA+F2eORyktQnljWLVJ7Eq5xHyPNB8nbLjWDV99hau1I7skbFhrGDRN6foh2AdQs1jNZYSzCDmYFd6CWI/BR3enJtVnaLRKCMjI4yMjKCUolgsMjs7y/T0NKdPn8Z13bZ/q6en5652NusIVrlcfiA8WEIInn/+eZ5//nmgWeXYsGED//f//l/+63/9r4yNjfHQQw/xlre85b7z0K0RrFWGO01klFJcvnyZY8eOsWnTJrZt22aU81diwPJKoHXBPnr06G0d05P/uy+AlHj9Waoa75U33Ev9ZD70eGTjMPUu31Jg2QTD/SRsC9woStioAGTdx464lC9dRpYtmCkCzW42Kxlrlqc03wc5qydqlmej+5ScdcMoTWK8yGRR43oDNWW9Sdru7YXLGr9QKgfTZhKnfbxvPWJaM2wasAr6dansENbk4vGlHUdF+pBuiqjjURM9BOUylOew60UEcxSySTLl86HSrLJdrLyBRGWHYDoc0qqEZSxDysx6nHm96dyq6/OyivYIGWlQCg0lxSCxDcs/TWBvb6am16pYpQvY8hIqJ7Fq4f0FqW3YdU00g9OHaISJlxRxhGx+NkoNQTCEXTlMEM9idUU5+JEdOKULBJHvAGtxQsJK+TaFEKRSKVKpFBs2bCAIAubm5piZmeHixYscPXqURCKxxL/VTXhuJ7oJVosQPggK1tzcHOPj4+zYsQNYnKSRSCT4vu/7vru8ulvDGsFaBejOwrpTUQ2+73P06FGmpqZ44okn6OvrM772XlKwisUmAanX6+zbty+ktq0EZKVG4f++goi41C6EDdjCsfGvNH/ZK9fFTqUR8RjKiRDgItbvRNYDanNF/LkSdt0n2hehdDrcDRjfvQFZDhMQb/0QDY3B3F0/TKBTqTwPecWkLOlVKruvB3UhTNZErhem9R1/lPQja0RvP1zWEL9YEmb0UQKmwE161yPmz7X/Kb0MZRUHJ0nETxLEHkdVK1Cag2oRmIHhDPb0MQThC2ccPcGTPeuwDcZ3YcrYym7EKhm20dX5AJkcxTZ5rGy96iojvVgdsxeViBDYm0GlUb4Lc1ex5UVg8bsgY0PYGnLVXJuJrK3H1sxLlPFdoCYR/nbsymEEC9/3qIfo+NhkAFbjLIgIyvvA0n1rAjhXArZtt8kUNK8Fre7EEydOUKvVlsRBpFKp21pO7CZY1WoVKeV9TbBa5PhLX/oSP/IjP8KP/diP8cwzz7Bz584l19x7oSnrZrFGsFYZ7lSae6sk6HneDeVE3SsEa2xsjMOHD2NZFg899NBtIVcA8//nZWSlRnT3JvypOezeAfA8EDYyADvu0hibotoQWKUA8mWgTHTTINXjS8mPDTi9aRoXw4RFuA6NS/oOOlXQ3xDtRESrUtkjg3DpXPgYqSRyXH8MSnqVysrloBhWb0S2F/J64iUq+vWK3mHEePg4ynGxZppkQAobFe1BeVmUiIEXx4+mUJVyc8xQo4ZDgSCqUBOX0M1xEY5esVDJXtyyQT0ql9BpnyqWwy7o1Tgi0c6os8Vt3Lh56HSsBzR+MiUckujfTxnbAP4ABHFEtYAoXsJW51HChoTbDP3s3l9iAMrhdUtvAKse9oxJQChNOZstWHWBVb2MYJG0B+4AqMWORtWwsWQK6eTxEx9slwbbzyt1R4zpnucxODjI4OAgSikqlUrbv3XhQpPcd5YTV7qU1U2wyuVm/fh+Jlgt0pRIJJicnOT7vu/7GBgY4N3vfjdve9vb2L59Oz09PfctuYI1grXqcCeIzOXLlzl69CgbN25k27ZtN3QBvFvesBaklJw8eZJLly7x6KOPcvTo0XZ34+3A1D+cpOpnUGN16peb5KkT8R0D1K/O0P3O2XFPZ2XBG85Rmw8rItHNwzTOhI3Pdn8P/niY4GAJ/DF9JpYg0KtUgwOo82GCI7I9qGk98aBkiGDI5aCsIQSJNMzoSZyQzRY4aUdRsV6Um0SKSNP4Xsij6kUozoGswgLZsPsyUAg3CQTpHtzZvOYgApE3qHfZfpgIn6cSgqzQk8JqNEuirI9NEGVTpMRGnIKhPOjrS7oytQWn2iQsgd2LtNZBEIFSHqHK2KXwd0NmNmMbvFSWb1hbYgS7ppkEENuyZEi0FLuwKjZCVduBo0v2k1yHYOF7Wfewq3X8ZBnlbgYnHDB5N6JdhBDE43Hi8XgoDmJsbIyTJ08SjUaX5G/dShyEUipEsIrFIpZl3bYfgHcCLeK0d+9eXnrpJf7mb/6GT3/60/zKr/wKH/7wh3nTm97E933f9/HP//k/J5lM3hMd5svF/bfiNSwbnb8Abmeae2t0zMTEBI8//viyZkbdzIDllUK1WuXgwYM0Gg327t1LIpHg+PHjt2095deuUDp8gchID3VNycvOJamdC9+sRMSles4QCDmlL6uh9KTV68tQz4dv8O76YeSVcLlNRCIoE/GqlfXEqzeLKmlUqnQWZjTkDqBmUqkGUVfyqFgOFcminDhKOchAIGYLqMoglEu0oyEAe/NWuKopHeZ6oaAnfsIQrErfOsScvkMPX2+8J7cOUdRvowJDSTE9gq3JywIQlv77KKM92JWlKpFCoKIjSDHIzLwkQQWnNo1FsySsIhmswPCd8SLajkMZH8Gum7xc+s9TRlJYdQslHsEqV3ErTZWr0bcHu+sy1BwCfaYpHlajWPUKYIFVJ4j+un7/90B2ni4OIp/PMzMzw9mzZzl8+DDpdLpNuDKZzLLW3LoOdRKsVkTD/azutOA4Do8//jiPP/44P/qjP8qnPvUp/sf/+B98/vOf59Of/jSDg4P8wA/8AO9617vYvHnz3V7usrBGsFYZbpeCVSwWOXDgAI7j8Pzzzy97dMzdKhHOzMxw8OBBent7eeqpp9q/km6n6X7m75tBkF5fAn88TLBi63NUjuVDj1vDWdCUAb2RXvxJDZGJuPiG8qAsGAzmMU9vYh8dQl7QDF2ORpETeuJFTdMGB1i9vXAprB6RSMH8NGSHUJEEyvJQgY2sNlCFCHIuB9M+ML3wH9gbNqBM5cm8nkRZ2RxoSnrSdnANSfAiFgPNW6YcDytvKPXFEq1+gqXb2B6Jhp6QzPuOvqSIwCrpiZdKjqDKc8jo+ub4maoPMxOIWgErc5pMLUykVHoEUQx/9xQCq3JOf5xYL1Q0kRKRIayGpgyoPETDwyquw+oIMpVYWDL8XZLJXQh5GGs6A24eISCIRJHRbwB7o3ZNt8uDdStwHIe+vr6257RWqzEzM8PMzAxHjhzB931yuVybcCUSiWsSJR3BelAM7i0opdrG9ne+8528853v5MiRI/zJn/wJn/rUp/iFX/gFfuEXfoHf/u3f5t/9u393t5d7w1gjWKsMt0PBunLlCkeOHGHDhg1s3779pi54d6O78dy5c7z22mvs3LmT9evXL7nI3S6CpfyA/P85DBbULunLOsGcJjsAqFUroRl7AE5PikBDsKIbh/Tlwb4c/rimPCUgGDcQDNP1v79Pn2UVjaEmNMRHWM2dDWwEJ4LEQdYVQamKFU9TPXOSZrm0g5w5DrYrQfO9Fa6tVc9Ebz+YyFJDT/zqyR7ihvKcqOoJKb2jiFmDIb2mL4OSW48wzCuMu/5iJkYHgtR63PoiKZFeDyoyjAyiqKKNmowvqEgT7U5GmRrGMRnSLV2hGWRqPbZvmNko9YqXjA9h1xaVVSXSBHIXQga40+Eh0TK1DUuGs6+UK3HGclilMnJB/JYRBxn5Be1x4c55sG4FkUiE4eFhhoeHUUpRKpXahOvMmTM4jrPEv9Vd9mtdrzvP80GJaOhEN8ncuXMnH/7wh3nrW9/Kj//4j/OVr3zlnuk0v1GsEaxVgO4uwpUiMkEQcOzYMcbHx9mzZw8DAwM3va876cHyfZ9XX32Vubk5Xve615HNZrXruR1/zIWDZwnmK8Q2D1C/ECYATn+a+hWNsuBYROdKWjIRTBu67oTeQ+b2Z2nMhY/hDA0gp8IEQwmQE3qyYgnNe5RIYQ2vA7+CEi6yAUGlQTBfQRbr2IfHtdEQ7la9MdgeGjIGkqo5vY/JymT0BMt1YVpfZpWGoc9E4jBnIF4Gb42KpIzjeTDkKSknilcNbyOxma64eNYWHOnhlYrY5QJwqZksH1cIqfnbSWZhVmN8txwsjfcKgGhGq7pJrxe7dk6/jWqSTymGUf46rNlTOPIQweAj2uwrFY2EHpdWGufSGHapjIw1CYUSNn7ih8Ey+5fuhRLhciCEIJlMkkwm2bBhA1LKdhzEpUuXOHbsWDsOIpfLkc1m24HHndfxB2UOYQutsOlqtcqlS5c4e/Ysf//3f88nPvEJLl26hOu6eJ7H+vXr7/ZSl4U1grXKsFIxDaVSiQMHDmDbNvv27bvlrpk75cEqFArs37+fWCzGvn37jOGBt4tgzX2hWSqxk3pzanQoQyUfJkzxLcPUT4dLRO5ADn9Ko4TZgsZlfelO1fT+HyebpKET1fr7UDOLJTURT0AyRbHuEyWKM7wLWQ3wCxX8mRJM+0SiAv9sWFVzN46irmrIkgA1pS+bWVF92VLkekAzcBqAumYsDyD6h2BaTy7cuoZZsNClOGXwhhmM6mSHELN6BUvUNOVRQGXWYxWOobwcMjqElDFkoYqamiTX62LNhQljPTlArGHwbAX681GZ9Yiqfo6gCAzREckhqIaPL50M+DZB7QmsuRNYHUO5LT/cFCCxsIKl77/yBaIUw67lmw84C6OzohvA+w7tetr7u88IVjdaw6hzuRxbt26l0Wi04yBOnjxJrVZrE6m5uTnS6TRCiBUtEf7O7/wOv/qrv8rY2Bh79uzht37rt3jmmWeMr8/n8/z0T/80n/rUp5iZmWHjxo189KMf5Vu+5Vtu6viFQoGTJ09y7NgxvvjFL/KXf/mXjI2NEYlEWLduHe9617t4+9vfzjd90zfdd6b+NYK1yuA4DpWK/gZ7o7h69SqHDx9m/fr17NixY0UucHeiRNgqZV4r8LSF20GwVCCZ+/JxEIrGFf1NNijpDdOWIcvI7U9T04SCeusGkZfDNzgR8dr5Wt2QxSaJEMkkViIF0RiFUg07lkL0panPVwhmK6iZBlDG70liXRjTjbEj0JE+wIo52vmG9kA/asZACE1+sVwWVdIQLMsCw74s0wU6msCrGEzfjv77reIZrKKBYJm2iaSwiotrU7aHTIwirTQySNAolhCFeaBj/V4UoUloB2jYDjGdSuREjGOAiMRBwz+Vl0ZoPFZAaDyPEg5B5GGUn8YZ+3Lo5UFyHU5D47NKbcGSix2KsmqjTo7gjCy+98pt/t3JWLhrMLS/+5xgdcN1XQYGBtrVgEqlwqVLlyiXyxw8eJADBw7wv//3/14xg/uf//mf8/73v5+PfexjPPvss3z0ox/ljW98IydOnNBWJOr1Oq9//esZGBjgk5/8JKOjo5w/f15bBbgeWp2RH/7wh/nN3/xNisUiqVSK3bt38y//5b/kLW95C2984xtv+RzvJtYI1irDrRCZIAg4fvx4+5fOrZQEu2FZ1m3rbpRScvz4ca5evXrD3Y23g2AVD58nmK8Q3dhP41JYrbHTMeqaxxGK+lX9jVzpBigDTiKiJT7u+kFUfhYrmQSvmfgufYEMBOXpPI1CD2rapxnEtED2RgTlybCyoeKudl6f3Z9D5fUES80bcrHSSXQWHxGPozRp582d6X1EVv8QzBiM51Vzl6KY0K9NGEiUyA7AlJ4oW2VNmVdYyMwmlGggGy5yvoQanwI5C8xi9fcvkKuu4/QMI/J6xSnpNbRkqehkySi9l0/4ee3jMjmKrSGZCqtdHpR2BmnvgImrWJUzyOHt2n0Rz+lJXDTRLg/Kchx1IgeNBsgGIFAocFSTwCW+W7/vzjU/YASrG7FYjFwux+zsLK973evo6elhfHyc//E//gdXr15ly5YtvPDCC7z+9a/nm7/5m9vBqDeKj3zkI3zv934v7373uwH42Mc+xt/+7d/yh3/4h/zkT/5k6PV/+Id/yMzMDF/84hfb0RObNm26qXNrEcQjR46wZ88e3vjGN/Lcc8/xwgsvtF/Tisq5X7sl1wjWKsBKJLmXSiUOHjyIEIK9e/cSj8dXconYtk2tpk+pvhVUKhUOHDiAUmpZ674dBKvwT00ztJOJ0dBEKrkjWRqnwzdFezCHnAzfyK2oR/3yUgVHRCPY6STKcnC2bkNhI2sKv+zTmKsiK2kqZ2doDuFbPFZ85yj1sfDNXXkOTOe152PX9ZEGdk+aQEOwrFQCaVC2aOiJotXfB5f1REHNGohPIgE6MSoShVlDerxtuEnH0tpuu+bi9Bd9FctglcZRsR5kdKBZ6ivWCSamsbwI4qqmRBmJg6YECJg9W27MOO7HSyb1Xionhm3oRsQxJL4nNyCcBkrtQFw501agFCBqhtFFykBWZdNjFsz3wMkISAmeQLSs+Y4CG2RkA1jX/1t90AkWLHZKCiF45JFH+KVf+iVSqRTnz5/nHe94B3//93/PL/7iL3LkyBF+/ud//ob3W6/Xefnll/mpn/qp9mOWZfHCCy/wpS99SbvNX//1X7N3715+6Id+iL/6q7+iv7+f7/7u7+bf//t/f8Ojg6SUbV8ZwM///M+zbdu2dik0CIL28/f7Z7tGsFYZbibJvZVuPjo6ys6dO2/baIqVJjTT09McOHCAwcFBdu/evazZYbeDYM1/rZlBFMzpy4DFwpy2S9BKRZGTzVR2O5PESsSbg5tjcWS1SlANaMw3qM9WCKbruCUPXjOY0j39Z2eZSlr9KZjQjLpxHVxDt6MI9MqS3d+DuqS58VoCafJfuY7ef9XTA0WT/0rfJSh6B2Da0CFXyev3lesHQ8aYKC+SXhVJIRNDKBIExFFXzsCVEtBFgMuGzsKeQcS0Xl2zWt6kbmSHEEW9shURehvAvJWhxzDSRtSXfgZKOASx3ahGFufyPyFYSvJVagRbUwZsDn3WBJhGB7GCy9QubseaqGLJ5g89EV/8hNXCHSlIXNt71d7nKiFY3deuUqlENpvlzW9+M29+c7OUutzr1dTUFEEQMDg4uOTxwcFBjh/XB82eOXOGz372s7zjHe/g7/7u73jttdf4d//u39FoNPjgBz94Q8e1LKv9mSml2LNnz5Lnbdu+o3MebyfWCNYqw3JKhK3S2pUrV3j00UdDf4h3a13Xg1KKM2fOcObMGXbv3s26deuWvY+V7mqsj+epXZpqlgE14aKBLYhaDu7GEYTnoUQzRDM/NY9XiBL4A/jT9YUg8maMQebxGKUjYZIRGc1SOxm+idq5BI0J/Q3en8lrHxcGQlZLR4nPaVQnAcGkwX/lWnr/VX+f0TOligbSkc3oCZZlwYyBXEYN/isvBnOG4FHNeBwVSSKTIwjXJYgOEMzMo64UaOVz2Zu3QFFDoqMxmNMTSWM3ohsFUzdiJKLP2XIiWEW9spTq6YG58HN1J41Xa75v0u0lsDbDlTFE5QJiRN+NqhJZ7UgfmVmP44cT54P4EPXjfVT/SZDaOQ+tOQXeIhlUXgwlFEH8X2mPGTqWlPdlwvdyYCJYvb29Sx67E0RTSsnAwAC/93u/h23bPPXUU1y+fJlf/dVfvWGC9VM/9VOUSiV+/Md/nPXr1/PHf/zH2LZNJpMhkUi0/4vH48RiMaLRKLFYjEgkct+VCh/sb+YagJtLci+Xyxw4cACAffv2rXhJsBsrRWgajQaHDh2iWCzy7LPPkk6nb3o9K6lgzR88T3TbKFY6jarWCBrQKAeUpkr4cw0igynKR2YIZUB5FooKBOGbnD+rV5Asw4+/6HCW6qmwguRkk/gajxUABb0alOhJo+byocdFTwY1r1d8VNGwXoP/imjU6L8SSHP+Vd5ASOqGxPWeAZjWrw2/huzdiiRBUFH4UwXk5QL2hgRiPDx7DwDTzMSeAZgxPGfyhuUGEfPhgdwAwtd3CZIZQZT0OVuWwX9Vc3uoyBh+MUp6fhpBs5ytLBu7ZCgDov9u4DqhLC+loPaKS+1I82+q8z4pvMUXK1EjiG69ZjRDJ1azgrVxoz589UbR19eHbduMjy/9cTE+Ps7Q0JB2m+HhYVzXXbKe3bt3MzY2Rr1eN3Zld+IjH/kIjUaDd77znaxfv77t/+qGbdvteIZYLIbv+5w9e/a+ClhdI1irBEIIlFI3pBSNj4/z6quvMjIywq5du+7IBWwlSoTz8/Ps37+fZDLJvn37bmn+10oTrLF/uMTkV0rkHk9ReFWT3t6boHglzDLEQByuakhRJkrtqkGNmjL4XwzEyxvKUH8tH3pceQ72vP4mbvu+Lg+TiiPQpfOISAQ5bfAyGUuKfaCLdABUQU/irEQK8ronLGOyu1joLKx7SWSsF8fN4JcCgnwVcWi6yQ66dio8w6XT9WDWdBzDzcdxYd6Qhh/Rx58oyzb6r/AMw6LtCFZ5qflPuRl8bxtezcUef5VuSazsZUlLXTaawDKM9LGCpQqiVFHmDz9CcKHDY9nBjoUjFx+K1gmS36k/Lw1WM8G6VaLheR5PPfUUL730Em9729uA5vv50ksv8eKLL2q3ef755/nTP/3TJe/7yZMnGR4eviFyBfDpT3+aQqHAzp07Afj1X/91CoUClUqFQqFAqVRa8l+lUmk/t9wJIXcbawRrleFaCpaUkhMnTnD58mUeeeQR46+Y24FbLRG2Qvq2bNnCli1bbllKXsmuRqUU+f3Nm2FNQ5YAVE1vGLeielYUW5elcjJMftzeBI1J/TH8aUMHn8HgLXMJnBlN44ElCDS+LIBMJoU/Ezbk+7kk9oxeQVKzhk68SETrvyIWhzlDpIK2CLmgHhUWyIVlo9L9qEiGwPeQBRc/P4Iq1YAi9QWSYY8ML5ArDWr6cxF9A8acLWHI2SI7iJg/p98m0KtEKjuCqOj9ZEjDNulRRPUECoFMbCeoJJFnLyLkWcSAbkAPuJkcaNLtg8QwbqCJYfAy2PVFsugzwJW/3kE0XmHJN7mTYFmK5getwPGQsbfqz0uDNYJ1a3j/+9/P93zP9/D000/zzDPP8NGPfpRSqdRWld71rncxOjrKhz70IQB+8Ad/kN/+7d/mh3/4h3nve9/LqVOn+OVf/mXe97733fAxv/Ebv3HJv3/0R3/0ls/jXsUawVplaBEZpdQSEtLKWZFStgce3411LRedafJPPPFEe/7XrWIlFazSa1M05qpEBpPUNYGVwhZULhgIQ1nfWWm5+ptKZChDTROFYKejNCbz2m2Cgv7Gn+rPUpsJr8sZ7EFN6lUamdcfA1dPFK10ClU0lCcNnYV2Xw+MG0bXdCtbkTik+/ET/WDnaOSrNK7MwYUGMAUCnKQDmg5WKx7TliGxBMyaQlENPi8hjF2CIpbQxl0owCoYBmzHEqDxsSvAKumVLeWlaVhPIsfm4cIUMIUAVCSOpcsTAzxHT/znA+jV3D1UcgT8ZndnXe3myp/1UJmKE3u0Sjs3REhQnd9fC5Ao2yaI7rzGXKYwVgvB6g7YXKlROW9/+9uZnJzk537u5xgbG+Pxxx9vD1gGuHDhwpL3d/369XzmM5/hR3/0R3nssccYHR3lh3/4h/n3//7f3/AxW9fV1jX2wIEDPPnkk+3nG41G+/lWwvv95r1qYY1grRJ0lgih+UfbModOTEzw6quvMjQ0xK5du+5KB8fNEJqWT0wIsSJp8p1Yya7G2ZebykmQEqARfmKbctQvhG/YVsSBSb0a4ecNgaSGbkBvOEf9TJhIiYhLY8yQLF7Vkzsnk2jdQ5ceOxFDzua128RdW6stlT2HhCH3Vs7oVTIR8cLEx7KgZxgZiyKjo/ilgPpkieByM88rsiNHcC6sxFg9PVAw5GxJQ85Wb5/ZeB7oCQnZfqgYSnqGPC8yg4iaJs8D0M6gAVRqENExeFkJi7waIiYGEFfBmj6nWdsAQkNyFWCX9WvOZPRlyIpfIwWUKk8z9udR6oWmd9MSi+u1op1rVyCbn6aKu/ip92iPZ8JqIVjd1+SVTHJ/8cUXjSXBz33uc6HH9u7dy5e/HA6XvVF0fl4zMzN8x3d8B+95z3v4xm/8Rh555JGbCi29V7FGsFYZWqSqla1y8uRJLl68yCOPPMLw8PBdW9dyFazJyUkOHTrE8PDwbfGJraSCNfVPTR+RUHpjdiQboa6xs8Q2ZKmeCSsLVtSldtUweNfkmYro/9QjIz34FzU3UUvQGDcQHN3cO5oBo/Ky/vhSUzYEiCYToJsnmM1A0WCWV8DQFqSI4VcFjdkatSvzeFYv8qjekG0y2NvZFMpEsAxlSCuV0ipOABT05ylSKa3iBCBKhvc5mQZDNJxV1R+HeA7mLiJjQ/hiFP/iNJFiEcklnKz+OyBM3YipQYSv91nZBuJnU+TKa49R+HwMWVj8wSNUFUXTo2NHOgiW14wXBZCxFCq6V39eBqxWgrVSJcJ7AalUig9+8IP84i/+It/93d/N29/+dvbs2cPQ0NB9/9muEaxVhpbsWiqVOHHiBFJK9u3bd9cHh94owVJK8dprr3Hu3DkefvhhRkZGbst6VopgjY+PM3vgMgJwy0qbri7req+XkzDMK1yfpX4uXDoSnk19zEC8yvq7uxXXG1PdgRxyWh/kKecN3YCGmYFWLo0q6dflyoZ2m5KwiHlRZDyD8FIgPRrzPrWxIk6xjCpX6QxKbZ2LNjPLc5GaUic0y7PabsRkElXIa7dBN+AaIJECw3maGgyIpRCGbTCMR1KRBJZmBqJyEwQqi19/GHl+HOhoEEj3IOqGcqNhZqFIZqEYJlgy0Y/th4msjIxSPZrl7H/bRs9o1/o6vGxWZPH7LrxG+2k/vTQP6UawRrDub/T19fE3f/M3fOYzn+Fv//Zv+au/+iv+5E/+hMcff5z3vOc9fPu3fzt9fX333QzCFh7sb+YatLAsi1deeYVUKsVzzz1318lVa01SyvZoBB3q9Tpf+9rXuHr1Ks8999xtI1ed67lZKKU4deoUhz77T4hygJuNUp/Q38hqYwbje11fBnKSelIUW9eD8jVrtgX1q3qVpDirv7k7Of3FW0RcgmmTZ0pfHnNyGf3rRVPZEukMYngjat0uGgMPUfJ2INRm5s+mKB6RFPbPUTg4SfXsLMp1FsjVjR/fHuhpJobrUNWXYO0evekbgIr+c7Sy5m1E1RADkenVPw6IumGb9OKIKiVsgsxOqu4TlM6kCS7OIq+GVU+R1q9NCYEoGsqdhp/fKh4ex+LHH2Ni/3aOfmIHQd1tGtc7j68WyaJwgo7/v0C2bIcgs7zyIKxugnUvXLdXAps2beL7v//7+eu//ms+8YlP8J73vIeZmRlefPFFNm/ezPve9z6++tWv3u1l3hTWFKxVAiEEUkpOnTpFEARs3bqV7dsNc8TuAloXkM4RCp3I5/McOHCATCbDvn37bnu44K0QrFYWV6lUYps3wjnOEBtNUz4evpl7Awn8WT3Bql7RExkj8UpFtM6cyFAOf0JfBvMqelIiDPcspz+HGtPfkINZ/XqFZ4NtIzI5iKeQRPBrAr/hUD03jqr6NOtniypbfJv+8w2SERyTZytv6JJMRPXdiJYwqnTCc80G97xhG1MMg22bg0w9/S9zJQRWwTA6JxJFsgFf9tE4N406MwPMNI8zb8gNM4zBId2H8PXlPqtuUONc0Z4zqIRLw3qCq39Z5cL+XlggUpallnjulFw8vuV2ECy3SbAqVpbLEw49PZVleSlXA8HqviZKKR8YBQuaP0Zb5/imN72JN73pTYyPj/OJT3yCP/uzP+PjH/84v//7v8/b3/52PvGJT9zt5S4LawRrlaBSqfDKK6/g+z7xePyeMxJ2mu87LyZKKS5evMiJEyfYtm0bmzZtuiMdJTdLsAqFAvv37yeRSLB3717O/Pr/BcCO6v/UYkNJShqCFRlKG8M/G2N5/cEDQ6kxG8fXzZBORqCgN8sbS4qJiNasbqWTqMIcIplEpDMoN0YQODRKUJ20qVzsg3OKziHSsV3DC+QqDN/Q8ZjMpmhMhgmOjLjIOUNYp9J/jnZPzkhIjAb3nj4oGBQf32CYyvWDIVldSIMpPjOAqC4lPjIxQOCM0Jh04PxVYOk+RU8/lPS5YaJhiIhIZiEfJljKiWBV9OcpgnxzPZEhGpO9nP6Mw8TZ7didKlV3GbWDYAnXod1SuJCBVfEeZnx8nJMnTxKNRunp6aG3t5dsNnvNH1OrgWD5vr/kmlipVFBKPTAEC8LDnAcGBnjve9/LW97yFn76p3+aT37yk7dlVu3txhrBWiU4d+4ciUSChx56iK9+9asrOgZmJdC6SHauKwgCjhw5wtTUFE899dSyJ8Xf6nqWS7DGxsZ49dVX2bRpE9u2bUMIwdzhpu8lKOjLWiZlweuNawmW25vA18QwAPizBi+NKdl9qIfGOQ3BsgT+hMGsLQNEPIaVzlAKACuCrWIoN0b50hWCSz7NDrdFghLJOdokemGImnB6U6iCoQxpGjDdl4ZJPSm8VoK8MhGsgkENSyW7rV+LMJjyRTyhNZEDYJhNKBJpqIKKZvFjG6lPNPAPTwFXcPv1UxVEIq4PGAWEQQ0TBp8XmUFEXTP823IQlcv48cfwj89y7LODXDq2iUz/LMjFL9rS+6VC+R2ftXTAqi8cv/m9iK1/A0/mnsT3ffL5PNPT05w6dYpqtUomk2kTrmQyueRmvBoIVreCVS43lfAHpUTYGcNw9uxZLly4wBe+8AU+8YlPcOTIEWzbxvM8du/efZdXunysEaxVgt27d7fJi23bKxaiuVIQQiwZl1Mqldi/fz+u67Jv3747nuC7HIKllGp3Yz722GPtDJmg0qB0dgZhQ/VyXrttUNQTL9NQ5shAiqqGYFkxz5xzVTT4jGKutqToDvZAvYzd30dVCuq+jWcnqc7UKZ6F2qU0i0mRVaBKak+MoBL+Tjm5ONIwTxBDuKrbk8Q3EKzAEAMRSSfxNdlcSkAwM42ORgjH1pcBvQhq3kDwTGb1aAyK+rUZSYwXg2KYyKpIkoAeauoRGscnQHWY02PXOI6l9y/Woik839CpaBq3E42j68gIkiNABn//eQ599ikmzjU7j4Vnd43HWVyLcIIluVei84WWQmEhM18HNLuc+/r62nl2lUqFmZkZZmZmOH/+PJZl0dPT0/5vNRCsblW/WCziOM4NJ6ffy6jVapw6dYojR47w8ssv8z//5//kxIkTCCHYuHEjb3vb2/hX/+pf8eY3v5lMxuDlvIexRrBWCbrnEd5rChYsZk+1RvWsW7eOHTt23JUL6I0SrHq9zsGDB6lWqzz33HNLZPvCyUmQiui6NI2rec1BoHZF8zgQlPRyuG1Ido+OZGlc0BApC21noYi4KMvB3bwBZUXwfZtGWVGZaeAGaYpHLtO8SSqaMduzCM/CEYaSloGwu31JfAPBMibLRwyhpMkYct5A1qT++HZfDmEYsKzqhiDT3h6YNswtrOlVMpHtMc4ZpGEwjWX6EHNNOUxFkgTJjdRmbWrHJ4lsLKPGNdlouR4wePao6aU134uGZgPCgs+rZOgstMLXhyC+Ab+8ieDsYQ689AyzlxbN9pZrIZc43RavN0tiGVjwcAUACgQot9c4ezAWizE6Osro6ChSSubn55mZmeHy5cscO3YMaIZhDgwMkMlk7kqG3+1Epz+phZb/6n4N34RF0vgXf/EX/OAP/iBzc3M4jsNjjz3Gu9/9bt70pjfxLd/yLfe9SrdGsFYhbnUsze2CZVmcPXuWiYkJHn300Ts6qke3lusRrNbsw1Qqxd69e0NekcLx5g0y0hvXEqzYcJrGhKasJBR1HSEDVM3cWdj5jBX1sLNJ6rEoxWqJSCSJJaPU5gLKE3XqF+skypLaRJ1uqaKnV/9LMTKUJLiqLx2agk+dmKudWWhnYgSGuAcahnPsSyMv60mMKulVOieTRBoIVm1qAp0GYCWiKEPMFPOG0uk1FFZR0JviVTSF7zxCbdaidnwS5OK+lSmDKxYBnbhmWQhTudMWWoJ1LYO7qC8eRCHwE09Qe3WMRk/AVz75z1DB0h89rVJfx0ZtOJHuz3Ph2uMECAF+dJ1+3V2wLItsNks2m2XLli3UajW+8IUvtKc5NBoNstksvb299PT0EI/H72sSAiypOrTwIBjcW5/L+Pg4u3bt4s1vfjN79uzhhRdeWEKquieO3G9YI1irBJ1f0nuxRFir1Wg0GszOzrJ37967fgG5HsG6cuUKR44cuebswxbBsgwlIq83riVYkYE0/lReu019Mo9wbJxsAisRg0gEJVxqxGgM7KA271MZr1O/2Px8rc0O1iWXZmLloipmx11qk4ZQUENnoZOOEGgED8uzaWhGAAHXULZSNC7oCVYwZwgFjbn6bkBbEMwYvEyGZHsRj+EZYhDq9Ro6PUUkk1A1HEcY4kUSaah1EKd4liC+nuoUcCVOcO50eF/pJBiCRIX+HYBsD1T1qeu2Nn0NSGRgTmNwt12sStOzJSM91AobCE5dpjCb5Guf3EB1PkKqd6mKJoTPkvpph+Hd9pZ+B8SC2igiTfIgszfnrWmRjp07d2LbNuVymenpaaanpzl9+jSu67a9W7lc7paGv98ttAhWp4r/IEQ0tK6XO3bs4H3vex/f9V3f1X6uFYJ9P4/IaWGNYK1C3GslwtnZWQ4cOIBlWezcufOukytgiR+sE1JKTp48yaVLl3j88cfp7+837qNwokmw/IJhnqDG4G4nIrjDOZxMDFyPSs2nUvaJ2En8wGHu0jzVmVrHDaxJnDJboXwhTHIyPRkKl8LqTmwkSfWcvnRVmzSYwk1EcSiNf1Wv0vhzhpE+Mf3NTngOwawpJl1PYpyeDMzpPUY0DKXWnixMGAheqaAnWJksTBm8WTVDg0Emh/IdfHeI6phP7dAsLXksslF/PnY2A1MGCa2if2+sZKodndCNqG/ornQM5bTUACI4g598lOqxeaheZWY8y8uffRq/3nxnLGsp0bNkDVg03y+JZYi0CD5gyfbHKLzmPvzc0uG/N4rOmXZCCBKJBIlEgg0bNhAEAXNzc0xPT3P27FkOHz5MOp1ue7fS6fR94d0KgqDtT23hQSBYrbLnSy+9xNe+9jX27NnDQw89tGSc24OANYK1CmHb9j3R8qqU4vz585w6dYodO3Zw5Yqh/f0uQKdg1et1Dhw4QL1ev+5A7KDSoHx+tumzmijg9iawExFExEO4LhKbinKR67ZSL0oq+YDyRIOgKhnKppn+Wpmld8wiuYdzVKfr0GXZFo6gcsVQbqvribSb8rT3YzcTNZb7pGHwtJuJ4muULeFa+FN6v5AwBMq6AxnUhJ4pqIqeENqZJIGBYJmGT4tYxEDXIGoYMl0OGhipf+fxhYXqWUdd5WjMJ2gcOwV0EVAB0pAbZiKf2BbMG8zqhmHaMpogEhi6G6Wh6zKWpVp6Gn9/MwZi7MIgh7/0cJtcQZhgia7wDiU7TO1Boy1uWZGOd92LoESAij2kXcf10Pr71Kkctm23yRQ0FfKWWf7VV19FKUUul2u/ZiXnmK4kbvccwruFVqD0yZMnKRQK7Wvp/V4S7MYawVol6Da5l0oGE+8dgu/7HD58mNnZWZ5++mlyuRwTExP3jLLW+sXY6lKam5tj//79ZDIZnnzyyesGnc4czzNvj2JFXa4c71QQAloelFjWplEI+40CQzaUm9AfMz6apG4wy9emDMqK4cd7dDBB9az+u9GYMpA4w768gTRyQk8IApNnKhWlYbASBdN57eMmciGiUVRBv2YhlJZgyXgcqnrFxzV1A6azIAvIgR3UKjHKr80TnKoBk8R26Tu9rGwaKgaypHz9+J5sDsp6UzqBnvyqZAbKBoKlKUP6mV3UJzOIS0cBOH9iA4e++Cix+FIyZupYbB836CgRLhn03LmdRHr93ZkON4zW3+aN3JAjkQjDw8MMDw+jlKJQKDAzM9PO3orFYm2ydb3srTsJHcEql8v3vYLVur5+3dd9Hb/1W7/F3NzckscfFNwb36I13FHcbZN7sVhk//79RCIR9u3b154zZSrL3Q10JstfvXqVo0ePsnXrVjZv3nxDF/SZw3nyZ2v0P6W/EMYGozSm9CSjOql/HENgZqQnSl0j/jlJl7rhGEFRf0N2UobZhLmYMW5BVU2erSh1A1nypw1lKwOJsbNJVMlQnvP1pni7Jw0mUlgz1NNSSTCUKLsjVuvxLAWZpFKIEr3oIWSR7sArVTZEZGRSRoJlHMWTTILhqyEMeVrK87TbKC+GqCwSL+UmqLKb2lev4G31kBJeO7idE/t3No9tdylWJs9Za39BRyZWhwHeina8h7KCTD56zf1cCzcb0SCEIJ1Ok06n2bRpE77vMzs7y8zMzA1lb91JPKhzCFuf2w/8wA/w2c9+lo9//OO8733vY8OGDWslwjXc33Ac566Z3K9evcrhw4fZuHEj27dvD5nvV2LA8kqgdQE4fvw44+PjPPHEE+1snhvB7LE8AI4hzyo+FGNOQ37chEN1XH8Xref1pKhc0ytOsZEklbP6MlB1zJR6rr9xRvoT1AwEqzFjIASGIFG7J4EyBHkqU5BoTxJpIFiyaDh+Ioo0cBg1n9c/YRp3I4ByATWwlVojSelsmfrJMqCI786hpOZ8hDLmdllRxzi+R+UNBneDUocXMYecCsMPlnQfVJpr8zO7KR1voOYXWPrcFEe+/DDnjm9e3E/3bMFrESwRLCkRNsuJCyN03MXPV3gQ5J4z7+c6WKkMLMdx6O/vb/spy+XyNbO37uTg4Qe5RCiE4Pd+7/eYn5/nN37jN3j55Zf55m/+ZjZt2kQmkyGRSBCPx0kkEriuy86dO+8ZZfFGcX+tdg0rgruhYEkpOXHiBJcvX2bPnj0MDAyEXnO3lbVONBaiAlpdjfG4Pj3bhNnjeQCCmsEDFdP/6SXWJyidDhMpYbNsn5WXdtHRK68vRpA3GbwNylbcRftMxCYweLZUw1DqzCVpGAiWnNOTJTti7iCUBhJjUsNEPIYqGUqHnUcRAnoG8d1eaiWP8uGr4DeDVZcswdKnIASxKG7dEOSp9J+ZlctCxZC6rvTvp8j2gIH82g39ZyNiMVSQpupvp/bVxbJjEE/z1b9dx/TY0iHUIc9V91vbYWp3IkvPTViq/bxlN7+RCoVwA/zcG7TruxHcrpDReDxOPB5n3bp17eyt6elpLl26xLFjx0gmk0vKibezrPWgKlgtgvWf//N/5uLFi4yOjvLKK6/w+c9/3rjNmTNn2LRp051b5ApgjWCtEtzNmIZqtcqBAwcIgoB9+/YZycq9QrDy+Tz79+8H4PHHH182uQKYPd4kENVxg5HY1yt1XsbTTTshPpI0ZmM5ZbTzAbXx5UC0L07ZQLBqhs46k2Jh9URhSk/Kgnm9EmcZyKXwHIK8qYNQ/345PVmY03cw0jCoYbkMGDolUSCHd1IteRRPl2mcrAFzRLcMgOEzM5nvYwM9qKt6ghUU5rQfj5VKoGXFAGWD6hiPGUfx2BW9stUIctTOlFAdQaONusMrX3iY2ctxovHqktGWoZFOXd8H1RHLYHUJbZ3fnXap0ZIoOwN2Sr/wG8CdSHHvzN7aunUr9Xq9XU48evQovu8vMcuvdPaWyYOl+4F6P6H1uf3BH/wBMzMzVKtV6vU61WqVWq1GpVKhUqlQrVapVqtMT0/T29t7nb3ee1gjWKsIQgiUUnc0pmF6epqDBw/S39/PQw89dM36+r3gwbp48SLHjx9n+/btnDx58qYulsWLRRqFBk7SoWwo99VmDLMJDUQm2huhrvE321GbmslnVTYQjLi+S83NRgmKesUjqOhJlIgbyJIjjD4rTB2EfWnUlKGDsGoYKZSOo6vOgXkGoYhFF03k8QRkh6jV40yfKmJPBFBZHEjdgjGDC5CGZHUr5mqJr0Kh5vJ6ghUxdBBawhxyajLfJ7NYwdLxQTIxQGluFM5VobT4nlZKEV7+v49TnG/+mLC6kty7Ix1CR+zMvRJ6T1xzxxKUhXAUQXyT+XU3gLsxJsfzPAYHBxkcHEQpRalUYmZm5rZlbz2oClYLzz///N1ewm3FGsFahbgTSpFSirNnz3L69Gl27drFunXrrktW7mYAqpSSo0ePMj4+zpNPPklvby+nT5++KU9YS71KrUtQOBUmOZYjKF0xEJmSwbAdMXi5RpJUL+pVivqUoTxkInEDyWt0EC6vG9HtT6MMWU6qYhhRk4piGJmHNChblmfwMrm2NqJBxGJIJ0Wj/1FKV3xKBwugmmn2KupgKz0pNb1ndjqOqoSPAxibEuxMGqumf28q5QK6wACR64WyIcbEN5D1ZAbmmwRL2S71xKPMvzIDjSmiA4t/i4W5BPu/8Cjl4mJDRncyuy6zrROyI9k9ZIhnMcFM2C74Abg+Mrvnmvu8Hu72HEIhBMlkkmQy2c7eyufzzMzMcPbsWY4cOUIqlWoTrlQqtez1PqgerNWCNYK1CtEiMrcrc6TRaPDqq68yPz/PM888c8NDOu9WibBarbJ//36UUuzbt6+dibOcgc+dyJ/IA+Bl9L9e4yNxqpf16kpl3EC8DH4mL+tRvRh+3Em41Gf0tSaTsuUkDb+2oxb+nKF9rWHwmKWj1A1kyTeUJy2DiduKR5EGNQqpP77Tk4XZMUQiicoOUK/HKV4JKJ4skao51M60Ftfx/c94kDeUdA0KmtOTQo3l9WszbGNnkjChJ1iOIYNLJBPmDsKKIWtswbBfjIzSuJrBP9wspYpEDCrN489OZnj584+HSn4hz1XXv7vpplKLt5JugrX0hQ4QIOIWjd43ml93A7jbBKsbtm3T29vbLmXVajWmp6fbsxNvJnvLVCJ8EAiWUorf/d3fJZVKtYlqy9TeMrhHo1Gi0SiRSOS+TOJfI1irCJ0lQiA0RHQlUCgU2L9/P/F4nH379i1r4vvdKBHOzs6yf/9+bQnzpgnWqfmF7fXPR3sjWoLlZlzqs/obbMFwEzd16kWHE1TP68lC3aRGGbi2yHlGnxUGU7zwDGQpEUEWDBlsgZ5E2j1J1LieYHX7n6yeHmSil6qTongxS/lEhaZDrbW9QBYMTMUwSBsgMJnv4/pZiwByzkB8Yp4x5NQ1dIQWykWyuiccB0p6BRPLZdZ/BP/YHIvnD3YuDXPTjF/u48CXHkUGNpHY0u9dqGuw25Svln5ZZGPxe2h33Qc7/Vn49San9eIQ3ahf9w3iXiNY3YhEIoyMjDAyMrIke2tsbCyUvZXL5bTXYillqHPuQUhyh6YS9973vtf4vBCCVCrVDo09derUHVzdymCNYK1CtP5gdb+ObgWXL1/m6NGjbN68ma1bty5bHbuTMQ1KKS5evMiJEyfYuXMn69evD633Zgnf3ALB8sv6W69juJEnhuOUTmsIllAwZzBY1w3KVlqf1O4kPRqzeoJhmkFI1HATs4F5g+Ji8Fk5vUmCq6akeENSeyKqJTHCc1FuDLluN5W8xfzpKvUTPlAn86RL+XJ4f8IRNKYN3izDn4IVdY3djaYSqYhHUeXlhZyKVHLJ3MJOJONRrZFdpTLQTcpsl3r6YaonJPJqWEa0EhEu7h/m8NceahOl0Ogb0fV9k12l6+7Zzh0fkBURLJk83u4wVO0NZeTWB7nf6wSrE9fK3jp58iS1Wo1sNtsmXK3sLd/3Q7EQD0qJ0HVdfu3Xfg3f9ykWixQKBUqlEoVCgatXr3LmzBkmJyfp7+9ncHDwbi/3prBGsFYhWkM0fd9flsJkgpSSY8eOMTY2dt35fNfCnSoRBkHA0aNHmZycbKfI62BZVnukw41CKcXc6SbBqk7oCYNsGDoI0662g1BkbFRRT37qeYP52+CZiQ4mqJ435GzNGDxbhnuYlY3BvJ5ESJPPKtEd17mIYOYa4aNCYPX2oBJZarUoxasBlSsSTpTQ1s4M3yO3LwmzBrO4YRunLwUThiiKuiHWIpcyh5watrGzaZg2lA6l/vMvSbVE2fJ7dpA/YdM4OEtc02imFJz+SorzBweWqFBWt2J1HQWrc9YgKJSy2gqo7dImWMIOaJdhbbnwGoVM79Cez3JwPxGsblwre+vcuXPYtk0ul6NcLoe6mFfK5P47v/M7/Oqv/ipjY2Ps2bOH3/qt3+KZZ5657nZ/9md/xnd913fx7d/+7fzlX/7lTR8/Go3y/ve/3/j82NgYP/RDP4SUkr/4i7+46ePcTawRrFWElkIjhFgxMlOpVDhw4EDIv3QzuBMlwkqlwv79+xFCsG/fPqLR6DXXs1xFrXSphF/2cRI2FQPBahgCQ033CisjtOqFcKA6pldWZM2QQWWYQWh5Ng0TwQr074GV8sDQKOjPGsI/DcTPziZQ5cWSmtWTQaRy1P0o+fkIM5fBPxHQTJxq7juxJUvDUG40zk3MRmkYAuFFVd9g4CSj+IZEemnourTiUWPXoTJkVlnRa3hMCvpFp3tzMHaVWryfmas5ONw8bxXzUF3eLKXg5OEtXLmYIRJd+v6ETPzXEZ+XxjIES8rLwpZtgct2F7+HltP821aWIhj4hmsf4AZwPxOsbnRnb83NzTEzM8PU1BRnz55lcnKSf/zHf2T37t0Ui8VbLhH++Z//Oe9///v52Mc+xrPPPstHP/pR3vjGN3LixIlrRkCcO3eOH/uxH+Prv/7rb+n4LZiu90ophoaG+PVf/3W+/uu/nl/7tV/jx37sx1bkmHcSD8a3cw3LxkqkuU9OTvLFL36RdDrNc889d8sDU293iXB6epovfelLpNNpnn322WuSK7g5wtfyXyVH9RdAYUHZUCIzzSAUnv5uFxtMGvO06gaztqmlPzKYDDuXW6joiYcVMZnSPWTBlP/VdY5CYPflsEZGCdbtphDbzcWxLbz2pSyn/pfi/GcrzJ+t4xfDn4NrGOsDGMugtslnZYFVWJ4aiC2M3Y2h3KgWPAdVMLBSU7U+FoeawTdmOZSjTzHzT3G42EGaUku/274vOPzKTq5cbJbmwib26yW1d3muWCxb2aGuwcXPeAnBav1/20LlntKfzzLwIBGsTliWRS6XY+vWrSSTSXbs2MGGDRs4cuQI733ve5mamuIDH/gAv/mbv8nx48eXrbIDfOQjH+F7v/d7efe7381DDz3Exz72MeLxOH/4h39o3CYIAt7xjnfwC7/wC2zZsuVWTnEJWhUVy7KW/AdN4rlr1y4+85nPrNjx7iQevG/nGm4It6JgKaV47bXXOHDgALt27eLhhx9ekQvd7SoRKqU4d+4cr7zyCtu3b+eRRx65ofXejIKVP9lUDSKGDsLYYJygqj/H8qRBQTJcQL0e/cgOYUNtUq8gKd+Q+p4xjP8QClHQl6cahiBPr09fvhBRD2l7WJu34o/sIu/s5PyFTZz8QprJCynOv1Rm8kCZxlzXzD/T+2KaWxh3CeYNBNMQneD2JI1KnblTMQ2G74eQBsN+LmvMARO+/v20dF24XpRazx6mX3WZ+9pUiBzHe9Pt/99o2BzZv5Op8cWgxu6uQCHC0Qqd6F6yX7lGLENH1MVSBav5OuXmbnrAcyceVILViSAIiEajDA0N8Ud/9Edto/c3fMM38Dd/8zc8/vjjbN++fVk/luv1Oi+//DIvvPBC+zHLsnjhhRf40pe+ZNzuP/7H/8jAwAD/z//z/9z8CXXBtu02oWoRrRbZgmbT1KVLl26KRN4LWCsRrlLcbOZUvV7n0KFDlMtlnn32WdLp9PU3WsaaVppgBUHA4cOHmZmZ4XWvex3ZbHZZ61kuwZpf8F9ZrkF16o9QnwiTH+FCfdIwgLhuIAWGRPRIfwJ/Wt/B5htUGjui35eTjSFMgZ0Gg72diiJULyqepBFEqMxbzF0KKJ6sEzsLQcWne7iMiSy5PRHjrEFMZLE/jn/VYOSvGSIqsjF8QxnOlNvlpGNIUyC8YcizlYiCIRjVNORZxDq2sR0aPbuY2l/Hz88R6zGQNafJuaoVjwNffQjfX/r5Xlex6v539z873vowwVp8slUWbK6p+f9lfJ12zcvFaiFYnedYXYj++MAHPkA2m6VSqXDo0KFlzeibmpoiCIKQcXxwcJDjx49rt/n85z/PH/zBH3DgwIHln4QBFy9e5POf/zy9vb1Eo1FisVg7liEajVKr1fiN3/gNTpw4wb/4F/9ixY57J7FGsFYROrvkbibNfW5ujv3795NOp9m7d++K55KstAerXC6zf/9+HMdh3759yx7SejMK1tzp5h1XGlQqx0CKrJwFs4ZzL5jeE8Ng5t4Ivt4rTd2kbBnOsxFVeKYxLAH4vUmcVJZy1aKYVxTHFPbxKMGp1k1hkdB4PRECg2fKNLcw0hujZiBYxrmJqQi+JvUeMM5NtGPmuAXT3EYRNV8+g7wh3d2zzUOeDQOorQWTf9C/i+kjUDvYfD/sVAxV1ZNCETQoFGIc+OrD1KoRYvGuOItuAmVdW1FSyur6d6dB3qx+df7QaClYQXLrNY91o9BFGDxo6O70LpWa39+WBysWi/Hss8/e1jUUCgXe+c538vu///vLGnhvQuucPv3pT/P93//97ccdx8F1XSKRCEEQUCg0/+7e+MY38r3f+723fNy7gQf727kGI5ajFimluHTpEsePH2fr1q1s3rz5tgSUthSjlQhAnZqa4uDBgwwPD7Nr166b+qV7MwRr/kxTwarNGvKhDIngmeEMhdlwS70dtaCov/UbR+HEDKNweqIE8wZTvMkUnooSNHxifb00cKlVHcozUJxWVL9Q03K8nqEIJY2VPtIboWYgWH7BQJaShiHTQGPaYDA3ZIMJz8I3ECxjp2Q8gjQMhraE0nZEWpkkGIiPKd3dSqehrnHSC0FDJMnPPkT11aVrd3IJmNIfJ3/OZ/+XHsVvuAu7ubZiZQp5bUHKpX+PSi6+Yd3lxk6KJdwIreHYYkHpktmHVsSbsloUrE6CVSwW8Tzvln7c9vX1Yds24+NLxyiNj48zNBSOzzh9+jTnzp3jrW99a/ux1nXRcRxOnDjB1q03Tppb1/Ynn3ySF198Edu2yefzzM/PMzc3R7FYREpJNpvlTW96E+985ztvujP9bmONYK1S3GiJsDPSoDVC5nauSSl1SwSrc0TPQw89xOjo6E2vZ7kEq5avU52uIWwoG0pUfsnQ3WdQtmJDCWqXDBEN0wafkWkUTl+cSjfBEuBmYijXI7pzPb5ymc83yE808Oc8khNJZl5p3cQlLUUqsSEGytANaYjTqsiy8cZanzSU1Az3fTcTISgZAksNnim3NwGGGZAh8/0CnJ4EGAZgq7qB4KYTZoLVMLxn6SRMLSVYcnAb02diiAMSfyx8rnbSQ2rS8memM1zc398mV6ApCXb/27k2UWnIpaZ5KRdjGSxLLYl86LTLqKoPCykDTYKlEBsfuuaxbhQPOsFSSmkVrFuNaPA8j6eeeoqXXnqJt73tbUDzvXzppZd48cUXQ6/ftWsXr7766pLHfuZnfoZCocBv/MZvsH79+mUdv/WZPfXUUzz11K03O9zLWCNYqwjLLRG2Smy2bV830mAl0LqQdPsObhS+73P48GHy+fyyRvSYsFyC1VKv4kNxaob4hOqUnhSZlI1I1qN2SbO2iEVt2jDkuaPrz4o6uLk4ViKKyCVxdyao12zK84ripGTucgNhWYhXGjTlqBZpcABJfERP1gLXPNDXdI7ZngzzF8IEx8m6BIaQUaMpvzdGo2yIaDAEprqZKA1D6LksmUJOPWNulzGiIeZdI6LBoIa1hjwLgRzYyszZGMW/bw6djuX0K7AcETrO+NVeTp/aQDyx9HwE1/NcdS+0S7GqLL5eCLk0lsGSEHQw4U61qyOBVFgKZbmIWFZ3OsvGg06wWteeToJVLpdXJMX9/e9/P9/zPd/D008/zTPPPMNHP/pRSqUS7373uwF417vexejoKB/60IeIRqM88sgjS7ZveVm7H78epJScP38eKSUjIyN4ntf+HJVSnDp1ikOHDjE/P8/OnTt56qmn7uvU+jWCtUpxPQVrYmKCQ4cOMTo6ys6dO+/Ihax1jCAIli2Bl0ol9u/fj+d5yx7Rc631LIdgtQJGY30RLcGyoxbVSf2N3C8uc8jzuhTU69iJCHguynbwA5t6TTBdEszbCebHfCodvq4N3xBn7IuToX1lt0Upn9Mf3y+YoiO0D+PEbGPOl6njTiUwztkLiobSYcLFRPH8vCGiIWKbt5nVEx/btfUE61oRDQbDPq59zYgGObSD6VMepUNlWIicdbIxVM2ghgWLZ6MUXLowxMXzI801dJcELT1Rbj/f9frwrMFrdA12b2sIMBWWIrBS11zHcvCgE6zWD+DuEuFKhIy+/e1vZ3Jykp/7uZ9rB0R/+tOfbhvfL1y4sKLvbasqcezYMd73vvfxhje8gZ/4iZ9Y0jX4v/7X/+IHf/AHOXv2bHu7t7zlLfyn//SfWLduZRoj7jTWCNYqheM41Grhm1frV8T58+d55JFHGB4evmNrarXqLtf3NDk5ycGDB1m3bh07duxYsQuDZVk0GmalphvzCwZ3N27Ih8pZKI3Nxo7aSF8S35DGijoI10HZNhKLiuMy25sm4qWpl6CUlxQnfQb604x/LVy6sxxwLFBB+IYqawY1KG2b+A3VCX1JLRaLUiCsFMWGotQv60mRb4h7yAxmKBqIZ80wN9Hks7I82ziY2lQ6dTIxVNVAfLpn8LW2ySahZOgkMJQo7WwauvPBbBs5sJ3JCwlKr47R3V3p5GIwbupubO5LKbh4bphLFxf/VsNdgnT9u+u96PqbUyHP1TVM7V2jf1TQ6c/qeMYSSDerO5WbgpTytnhB7xW0CFbn9Wwl5xC++OKL2pIgwOc+97lrbvtHf/RHN3XMf/zHf+Qf/uEfeNe73oUQol0CvXTpEj/90z/N2bNn+aZv+iZGR0c5evQof/u3f8tv//Zv88u//Mv3JZleI1irCJ0XI52CVa/XOXjwINVqlb17996VeVfLNd+fOXOGM2fO8PDDDzMyMrKia1muglWa98k83k8Q90g9OYRCEEio1wPyc0W8jItwcjRqUC0GVIoB5bzfDL882xopskiWAIYfSTN5xIMu07hjULaSIzEqlw2jcOb0ZLFU05OYSK+Hb8iTcqT+0lGzKsYQ8MaMKfxU/3oRt5FlQ3SF4XNx++LIKYPPytCp6OTiBFf1BEtVTT6rOMpEsGqGwNJkbHHmcjSKn93K+AFF9UCd9GZDFETCMw+Tzs8jpeDksc1Uq0slxZCCFdaklv4zWPrdUPZSO0BYleowsncTrA4DPG0hWjWjH1LmlPDl4nYMq7+X0CIfndftlRqTc6fRUrBa2YmtkTytz/DP//zPefnll3nHO97B7//+7xONRikUCrz+9a/nv//3/86/+Tf/hl27dt3ls1g+1gjWKkW3Byufz3PgwAGy2SxPPPHEXWt/vlGC5fs+hw4dolAorHgeVwvLJVhf+cwcY0eKrN+T4crB7pKTYNs3ZDj/tfBNuXdLjPxJPckpjRsIhqHiE+/1jASrNKYnOIlYnLxm5k1iIErBQLDqhjJgpjfD/MVwGdKO2zTmTAZz/ecdG0jQuKLfpmKITnDTEWoa4zdAULwJn5Wh69GKOuZtDPMZrYiLSmepeBsZ+2plMWZCqOWPFkrFaBTnOX5kG/NzKRLJpesMbdX9QPe/u77n9UJXcnvQQagsCXKR2CwRkYRcQrDsppUPnACBYrxhUz53jt7e3vZA45vFaigRdhPIlVSw7gZOnTrFyMhIe/5r6/P/whe+ADRVtWg0SrlcJpVK8aY3vYkPf/jD5PP5u7XkW8IawVqlaBEZpRQXLlzg5MmTbN++nY0bN95V2f1GsrCKxSL79+8nGo2yd+/eFfFbmdZyowRLKcX0meZNrjihJx/S17OiWNYlr3ncTdiUpwwdhIboBi+h/0Ufzbk0DFEIVqC/SdkJ/fdAWFAZN5AVU55SGjAIPsowIshJOkbPlDJ51kyjcAB/ZnkkRjgWwZwh/NPgsxIRF6XpbhSDI8yX+hn/kgK59Hn3Wj4rQyJ8EEly/CtDlMvN8VShP9nrxDJ0M6yQvtVVIpQdpMlyRVcD6eLWjrt0vZalQILj+YDCG93F2Pw858+fx7Ztenp66O3tpaenZ9m+y9VKsO5HBauFubk5BgcH2+dlWRa1Wo0jR46wbdu2tiWllVm4efNmrZXlfsEawVpF6C4RNhoNDh06xMzMDE8//XT7V8XdxPXS08fHx3n11VdZv349O3bsuK1kcDkEK3+xQqMS4EQtCmN61aVuMIw7nv4mkR6OMndar6BUpkw5W/r3IzkUYd5AsKrT+sdLhmTx2ECUxpQhKb2iP8fMUIbitP59qc0YIhoM74twBcrg55ovzGsvak42Fhp+3IIpZNXJJcCguonANAonBa05iI6DGtzM5LkYs/+7Qs9jAl17odsTQ101+azCn02hGOXiuV6q5c7359qeq9D6ux/o9lwt2Z1CqY5YBkcQdCxrSbBo92+dhe5YKwLKlmR3vJ6sl2oPNJ6enubcuXMcPXqUVCpFb28vvb29pFKp6/5trwYPVjfBWimT+91Cb28vJ0+ebM+ttSyLL3/5y0xMTPBt3/ZtIWWr1VF+v57zGsFapfB9n2KxiOu6N5VyfrtgKhG25h+eO3eORx99VBuIt9JYTrL81GtNIpQejjB3Vq/uFA3ES2dIB4jlXO1UFdsVlAz7CgxG9kharw4IByoGI3vUi9DQGNmjPREjwarPGbr+jGQJfEO50TKoYW5PDGb0nqmYo+8udLJRpIlgGcbn2OkY0jDWRhrG59iJGEplqUXWc/lrPvVXfKD5fQiKJp+VWakL5sLlxqMn1hFNLX0/wzzj2p6r7tFuyo50Pd/hubLlUhLlYCyPhgSlFnmNOCii4KUWXtccaJzL5di2bRu1Wo3p6Wmmp6e5ePEiQogl6pZOpV4tHqxOlMvl+5JstJTGvXv38rnPfY4//dM/5d/+23+L7/v88R//MXNzc7zlLW8hlVraZXrixAn6+vruiR//N4M1grXKIITg6tWrHDt2DMuyePrpp+8pmV1HalpKW6lU4rnnngv9Ed7OtdyogjV5uqn2SE9PFrykTclU7jMpW4ZyV2okRumiXtmqzuiPoSz9LTExGKU+bog1aOi/F25Sf9kQFtQM3YCh2XYLiA0m8Sfy2ueq8/pz9LJR6gaCJQwEsxxUMKW4BfOmWAfXmGclC13Ex7IQIxuYrQ0w9nkXZJhM+TOGMT2O0BIsK+4iNblZQWAtDGe+cQXrejpPrbj0uxYahdNZIuz+Wnbs3JIdZyLk4rIE1+wgjEQijIyMMDIygpSS+fn5NtnqVrfS6XS72/heunatNEwlwpVu5rmT+P7v/34+9rGP8f73v59/+Id/IAgCPvnJT7Jlyxbe+MY3tl/XUrA+85nPsHnz5lvONLxbWCNYqwhSSo4fP87FixfZvn07r7322j13geouERYKBfbv308ikbgt8w+vheUQrDMvN4ffJTNxCoRLa5mRGPlT+pJbcdyUG6V/ON7r6QmWUJSu6lWSgkYJAYj1ekaCVZ0xKEsGz1K0L4rMG0bxGHxWXtbD10RXgHkwtRtzNbrawjYGEpPpyVCb0JAyi2v4rPTHEFEPVWpuY/XkqEZGufyKorLfp/91jr4MmIsglxkF4eYSoMnnktJCdEtQ12NQXYwrpG91qaiyq2uw889AiIDOW0e32tX+/07HRo06Kr7hOotsHc8im82SzWbZunUrtVqNmZkZpqenuXSpmbrb09NDEAQ3NbD+foFOobvfPVijo6N8/OMf51d+5Vf45Cc/STQa5Z/9s3/GBz/4wSUkSgjBV77yFY4dO8YHP/hB4vH4XVz1zWONYK0iCCFQSrF3716EEJw4cWJF5v6tJDpLhGNjY7z66qts2rSJbdu23fF1Xs8PBs2L4LFjx7hytBkR7jl6w308pzeyewmb8qSeyDRMY3UMRvZ4X5SGYRRMVMSoaYifm9BfAuyIoGqKO/D170m016Oc1z5lnjUYM7EYBfP68y+V9YTISXnIqmHWoKHtUiY9qBkKdAafldOTgsQwUxdjTPxDDTr0J1nX7yvSEyW4oidYUuOzgub5BBprlpQCIX3gxstjqqsrWHUntXcPcw7NGuzoGlQ+S24dHW9t51zCzqqjEA1UdnkjVVqIRCIMDw8zPDyMUqqtbimleOWVV0gmk+1SYiaTued+NN4sHkSTOzTDQ59//nmmp6cJgoDBwUGtQjU5OcmP/MiP8F3f9V337We6RrBWEYQQPPTQQ0gpqdfrKKXuOR9DK5/rxIkTXLx4kccee6ydLnyncT0Fq1arceDAAYIgQM5GAN9Y7nMj+vc4PRJl/jU9KSgZiFdIvVhAot8jbyBYjTn9uqRBPYkPRqle1RMZv6QnEabSIUDNMD7HNGTZ642j5vWExLX0iexOT4zgqmF8TlX/Xib60/iX9Ns0OiMaLIE9Osp8MUdxKkHhH8ZBM4bamDyfNEdBmEqUVkSfIi+VtUD+Fsn8dQWsrhtUOOeq6xhSLJrau4dad3U2hsqJC7C9xZ1aboAa3H6dVV4fQggymQypVIpz587x7LPPUigUmJmZ4fDhw0gp6enpafu3bvd4r9uJBzGmoYWWQnktfOu3fivf+q3femcWdJuwRrBWKTrn/t1LBAvg8uXLWJbFc889d1d/rV2LYM3Pz/PKK6+QzWZ5+KFH+KtzfwtAwVDuM6k+8ayrSaC6npHdMLcwoy+fWq4wGtmLhnEvkR6P6lXtU9QMXYe2oXTo5TwCw9w+1TCky+ci1AwVNcdHS7DKQRVTq4Y0EB8rai45B3NF6ukkJdnLzPEotf0AdQaeMXsA66aOSNcQ6+BaBHMG1c3gW5PYxueM6FJ/a3PdilXncMGlqnYoFT5UnuwYKt2xLtvrKBfGGvgDjy9vzddA6+8yEomQSCQYGhpCKdUmW2NjY5w8eZJ4PN4mW9ls9r5SQh5UBWs1YY1grVK0LjS+79+2HKnlYn5+nomJCTzPY+/evXct7LQFE8G6evUqhw8fZsuWLWzZsoWZs2WChsJL2MYMrJpJ2bqGkb14weCNmjV0vRkITmIoQu2qfl+ejFDXDMpxDaU727OoGuIWlNTf9KN9UaoGguWXDIOZ445GH2qiMadXw9I9aWoTGtVNQJDXHx/N/dYZ7qfq9jF21Gf+YvhzqxjKkG7aNZb7hGGYt9cbB4OZH1+vFHZGJiw+du1/h/dxjfmBXQb66w2GDnzRLsF2zh603aB9LGHbEFvZFPfm2joT5QXpdJp0Os2mTZtoNBrMzs4yPT3N0aNHCYKAXC7XJlytqIB7FUEQhK6B93tMw2rDGsFaZWhdkIQQoTT3u4krV65w5MgR0uk0iUTirpMrCBOs1pzGCxcusGfPHgYGmjeMydeaN/XMaIwZQyK7iXhdK5HdRLCKBiN71RAdEOtxqRnUqMasYZiz4Yd+bDBKzVA6DMrm0qEhj566YXyOKQPLci38vGF8j2NpSZlM2KiGnsgJJZuEYaCXyaJH8XyawgFFckME35Sib1Ajvd4ogeG9MUVBOBkPaVDqZEl/nlKK6ye1dx9fmgkVaEztnb6q66llgWwrZJ1ql2UtfB8shbRXdtJC6+/yWoqU67oMDAwwMDCAUopSqcT09DQTExOcOnWKWCy2RN2615T8BymmYbXi7t/F1nDXsJy5f7cLUkpOnjzJpUuXePzxx5mbm6NcNo0evrPoJFit0TzFYjFUupxaIFjxrMuMZj9u3KJkIFgNUyK7YWB0vM+jYejuKxnKU15CXwZzYhY1gxomG4YyZNYzkrX6rCEbykCW7IiNb8jNMoV/ev1x5KQhiqKufy+TA1n8y0vJirIt1EAPs+Usly8lqOxvEYPm/7oZB39cuzvcQO8Bq4ma8YLqzxsysGKOsSPS1N0YBBo2FVKwlr7G991rPr/E1C7UUuN6N8EK8a2lcwlb/7ZE88yELZGRlVOvYDHF/UYbX4QQJJNJkskkGzduxPf9trp1/PhxGo0G2Wy2HQURi8XuevPPg+zBWi1YI1irGLqBz3cS9XqdAwcOUK/X2bt3L4lEgmKxuKz5f7cTLYJVKpXYv38/kUiE5557LlRSbYWMmozs2ZEYeUMiu9HIblhTcjDCrCk+oeKA5nZtUqMSQzEqF/XxDQ1DUrpjIH6WK6gZSoemelV0IErD5FmrGUqq6Qi18KhDwBzkaSccfMDOJqB3kOmpCJde9mm8ArF+HzUXXp8XdzAkelGf1hPZRDpG7Yrm/bTAnzXMNDR8NnbCQxliHaTuN1Eod6GLYBWXdgKG9tlhahcL421auJaCJYRaUq5cMpZQND9DYUtU+uY6CE241Qwsx3Ho7++nv78fpRTlcpnp6WmmpqZ47bXXiEQibbKVzWbviqL+ICa5rzasEaxVjLtZIpybm2P//v1ks1mefPLJ9gXsXlDVWmhdwL/0pS8xOjrKzp07tRf1VolQBgYje49L/nT4cdsVxnR3f5mJ7LYnqBiUnbrBFxTNuVQuap+iahjFY7qnRfujBFN6siarhtJhJkLDoBI1DBlYTuwa3qwuEiNcG3e0n4rVw9VGiol/bK1j4cbvKNS8/jOrNwxkLW7jG4ZGu66tX1vCMjY5GDOwehMwZSJYYfqtumcLhhSta5QIhUKEVKiOp7uPpTpf23VeQrXJnXBd8BsIR0L/rXcQdmIlx+QIIUgkEiQSCTZs2EAQBMzOzjIzM8OpU6eoVqttdaunp4dEInFH1K1ughUEAdVqdY1g3UdYI1irDN3zCO+GgnX58mWOHj3K1q1b2bx585I1LWc8ze2EUqodarhjxw42bDCHJLYUrJoht8kxRjTEKJmM7DOGYcaGv9jkcJTyJYNna1KvnjhRQ1J7wqaeX17pMJr1KE3p12ZUw0yDmYWiYVCJhGF8jp30kLUy3mgvfizL9JjLxf0NGl9TrH8+xuTR8HtgZ2wo6L9rviEbK9YfwzcMupaGbRIDKeQV/TZB2aS6uQSa91PKFsG5DqHqymML514tNbV35mCFTe3dO+8kWNrlLzzpAA0sO0CNPnLdKInl4HamuNu2TV9fH319fQBtdWtmZoYzZ87gum6bbPX09Nw2daubYJUWhoivlQjvH6wRrFWMO61gtZLkr169yhNPPNG+gHXiXlCwpJQcOXKEyclmLepacw+DhmT2fJMMFEymaIN4kejz9ARLLH9uYSTrUL5kWGTR0i7CdHOMDUapXNSTIr+oJxGOIfwUoGaYW2gqXbqZKNIQJqr8ju+GJfBGcgSxNOUgxsUvlynvlzTrZYvr9w0p8unBBGUD+Yvi0dB0V/quaWogBEVDR2TSNapu1ek5beHO8vQZWMpeUDCv4YMCqBa6R98sfbXsiGUQlloipF3P1K46Iu5DapdYPJZaIOMi4iBuQ4nwTpnS4/E48Xic9evXEwQB+Xy+TbaOHDlCJpNpm+WTyeSKqVtrBOv+xxrBWsW4k2SmFcrp+z579+41jj64kfT024lqtcr+/fuB5mDSf/zHf7zmeqbPlJCBIpKyKZlKdAZS4hmiEJL9EaoGb1ZhyjCfz5DI7qVsGvP64xsHQ2fMpcPaMsfneFkPWTJkYBlKqpHeGDUNwbJiLtKLIrZtYWbC4dKhBtUDTUI1/LRLeVq/v8acIV096WooVBMmw76XMJvSTd2NxpE7jsCu6Mlfo2F4n9P6m2vYtN79gu7Pp1PBUkvot+VaSzJUu7f0/Y6A02uRsYYPLig3eR2pa/m4W3MIbdtue7O2b99OpVJpj/E5f/48tm0vGVJ9K6O9uglWsVgkGo3eEx3Wa7gxrH1Sqwydv64cx7kjJcJ8Ps/+/fvp6enhkUceueYvz7upYM3NzfHKK6/Q29vLww8/jG3bCCGuuZ7JhfmCmZEY0yeWN2vQdMtJDJoJVsUwMNoylM4SQ1FKZ/UEw0S8TKVD27OMBAsDCY30RqgZCFZgyMByEg5128IbTqOSKUoVj/HzcPWVOtnLLuXxGnTpO8ZyI1CZ1JMly3Dvs1xBzZCIH4tH9QQrKowxFYaPBrcnBkU9xauXy2jT6Raym0KE6jpjc5a+frHTDzQqlHNt4iKrnS2G5g7D9n5j2Wvu72awkh6sW0EsFmN0dJTR0VGklMzNzTE9Pc25c+dCQ6pTqdSy1txNsNYiGu4/rBGsVYw7QWYuXrzI8ePH2b59Oxs3brzuBeZuebBaOVzbtm1j06ZN7XVeb1zOxMlWRIPHtOZ5N2aOaPArBgXJMHLG8sDPG9K9DWpUNONiiLE0Eo9rlQ7NGViGuImUuTzWyDePb3l2k0wl4pSqLuO1KKdOujQOts61SWksByqmrkvDmqM9LkHJVLrVv5ex/ijBtCEKwpA8HxuIoQxp+TQM3rx0BKV/O4lbNrqtqu0fREtPuF6/cc+VEGrpv7uS2q3rVN6W+re6zPNLdrTwr4y5xH6zuFsK1rVgWRa5XI5cLse2bduoVqttdevixYsIIZaoW9cKeJZSopQKlQjXyoP3F9YI1iqGbdvU66aCx61BSsnRo0eZmJjgySefpLe394bXdCdLhEopTp48ycWLF3n88cfp7+9f1nqmFhQs29Pf4bPrYuQNswbLBjXKlMieGY1TPG+IezBEJJjUKC/jGM3n0kAirpmBlTeMz4l0mKdtQWQwicjE8R2P2YJiUkrGDtdRB6GpSgVs+bo4jUqY/CQGo9TH9IqPrOs/Iycj8A0MMzCU5yI9HmUdW8YcphrNRKlM6LcpTuV1gfG4CXfZGVgtM3pYwbpeF2E3wWLJvzvR7Y27Zir8NQ3wCoWC3Og1dnBzuBcJVjei0SgjIyOMjIwgpWwPqb548WJI3Uqn00t+fLZ+ZHaXCNcUrPsLawRrlaG7RFipmNJ+bh4tH5NSir179y5rJMWdLBE2Gg0OHjxIpVJp53B140YVLNnQ34XiOY+8RkOyLChcNXSjGfYVzbkUz+vXUTapJ4ao+MRAlNJZg2fMVDo0eMaEDbXpxXNxc5HmsOaYR9mJUFq/nqmrARNnG/gnFRCQ3QDlC8ubtRjvcamPaZ+iYfC5SddcAq/Pm8b0mCWclurWDfsaJUq7HGg/BdUdcbAAK+aiKvrIC9dp1jXDhGpp2a/bc6VUR85VF38PG9Wvn/reemRpiKxcXIOQzeNYEtm3/ToFzOXjfiBYnbAsqz3geOvWrdRqtba61epW7lS3WlhTsO5vrBGsVYzbQWZmZ2fZv38//f39PPTQQ8vu9GkpRkqp2+qxKBaLvPLKKyQSCZ77/7P33mGS5fV19+feyjlXde4JnSanntADRgjxGgkUsIQsS7bQYgm/xsCDjC1LlnlwQBZgbIQfyxKWLAnLNsLmFUGwsITNYWZ3pntyh5nOOVR1V1VXdeV73z+qq7rC/fXs7M7u7DJ1HsJUuPf+6lZ13VPne77ne+6c0Ix6N4JVSnFPCRLRDSbti4Cj2UxqUftinRF6o0QRBaAIeHIhLcrT0gtLh2mRZ0kHSEXjusFjRrYZKOj0FPQ6ErE80bUCa/M5UjMFihfbNHtOmVgcql+c1WNga1Z70RmBKd1oF3+WRLldbp+D9RmNfH1JJb0mGNMjUBBlg0R2Q2BkF5i99U4jakabLCXiUc3h1AaPFaLa2xS2ip+zXK728ypWtCRJrQkAre/8q964+vNe98pUqXw42UC5QVWn2/msyfL2vw0yurau+hfyKvFmI1i1MJlMNDc309zcjKqqZXVrYWGBkZGRchNQNBrF5XIhyzJbW1v3jWD91//6X/nc5z7H8vIyx44d47/8l//CmTNnNJ/7p3/6p/zlX/4lN2/eBODUqVP8/u//vvD5DeygQbAeYtzPHCxVVZmbm2NsbIze3l7a29tfEUEqfWlqDTq9X1hbW+PatWu0t7fT09Oz6zp3I1jpeI7NbQN7fOHeYhXsAZOQYMUWtKmPSG10tVjZFCTFZ6OCPK2a0qHeqsPgMmJwGzBYJMx6HQVJJluAdFZlM15ga9PEeMRGblGlGNZZ/Oy0HnGydkP7+OmYoAy3i0q0JfCsiUqnOpO0ywBs7eOYPSYUgcEcUXdjwIwqMvkLfqiYfBaUZW2y5DRbyVD/mGKWtBUfvY5EthhtIsgn1YRUEf5Zvl2F2gyHmp3rd2igVFKmtiHrpXIihqyvmEOoU8vbytb7r7q82QlWJSRJwuVy4XK52LdvH9lslsXFRaamprh58yZXr17l+9//Pna7/b685v/zf/4PH//4x/niF7/I2bNn+cIXvsC73vUuxsbGyvNVK/HUU0/xy7/8y5w/fx6z2cxnP/tZ/vbf/tvcunWL1tb7X/79UUKDYD1kqC0R3g8Fq1AoMDw8zNraGv39/Xg8nle8r5Li9Vr4sFRVZXp6mvHxcQ4dOkRLS8tdt9mNYM3diaPvt2CzG5DzYJMldEjISEVrSgFw6gj1u1DzoOQV1IKKmlOxBIw42i2oebV4v1JMgld1BZS0iqEyV2o7V1JSJXQOqeh70YGslzGZjVhbLMg6CUkvI+klJJ0EOglVJyGZwB4yo1D0WucKKtmcwqrOwJLfSTKRI76RJxdTYSlHqMvI+h1t4tF2QCaXqSeMZkFEBCA0+Ms67QuFyakjuykg/QJTui1kJrOkTfCUrMD87zOSFhCsgmBMj8llJK01bJIdZakWervYZ6UIzPd5CnUESxf0MzPbxtqINsmuFp3quwSrk9urt60rCearz1lmS5x7Jet2DlxWrSruVwwOzfW+WvwoEaxaGI1G3G43JpOJgYEBvF4vS0tLfPWrX2V1dZUjR47wkz/5k/zUT/0Ub3nLWzCZtHRQMT7/+c/zwQ9+kA984AMAfPGLX+TRRx/lz//8z/md3/mduuf/7//9v6tu//f//t/567/+ax5//HHe//73v/IX+hCgQbAeYtwPBSuVSnHlyhUkSSr/wnk1qFSw7icKhQI3b95kfX2dM2fO4HK5XvZ6RARraiTK0NU19h/1MHl9Q/M5Xq+FeKSeZBxtCXJrvv5qHdxjYkOQ4t60bmOtLmE9Q7szw/LN+m2cfiOpNe197T/pZXainmDYXNoDq0E8N1GkLJldemG6vSgDyx40k5zSJku5LUEHn8cgNN+LvFlGpx6Ray0X136dBusu2wgysPRGWZtgSSr5mPbrdLrsZJaLIbeqLLFub2bm+y4MrkJ9vlUJu/weKZrNK27XKlZ1b1/140VP4Pb4m5qOQ4mdfVeRrRLBMr3yH1u74UeZYMFORIMkSRw6dIjf//3fx2w2s7q6ys/8zM/w3e9+l1/91V/ld37nd/joRz/6svebzWYZHBzkX/7Lf1m+T5Zl3vnOd3LhwoWXtY+trS1yuVyVV6wBbTQI1kMISZJQVfVVK1iRSIRr164RCoU4cODAffnCkyTpvnvD0uk0Q0NDyLLM+fPn7+kX324Ea2Y0BoDVoe3fsrkMmuQKIJPUJh6+oION6XqKI0mwLhi3YjKaAQ2CFTAJCVZyXeAZE5i1DSaJhKDrUVSucgRMxAQEK5cUkKVdYiWyAm8WRjG7yAi8WXqj+LOaCYtys7SJpGSQhARLlFavd1pQs9qknELxnOlCAWamW1h5sfi6TW49Wc34iN0Vq/rRN7verA8lrdi8NpahMo+sXBYEZLn4nhTML697+F7xsBCsSmxtbeH1ennf+97H+973PlRVJZcTTxbQQjgcplAoEAqFqu4PhUKMjo6+rH389m//Ni0tLbzzne+8p2M/jPjR/YQ2cFe8UiJTKrUNDQ3R3d3NoUOH7uuX3f3MwtrY2OCFF17A4XBw5syZe5bTdyNYs2NFgiVo1CPQop1WDxATXfgFF3G7T0dB0F2oZrXPfU4RjKgBYoJRPCI3mqtZ3AmaFZBFq1v8+y0lIngW8edoSzCKKJUWz1rMCGYqimx3JrdRmCkmko9MPovwM6AKFGKjR6z0qvkC2ZbDXHoswEqFMmnzWraJU0W3ngbuZn2sU7Bqj7/btrUEq8KvJRsrSoklBct+/zOw4OEgWLWvL5lM4nDslFwlSdo1S+u1wGc+8xm+8pWv8PWvf/1VVyseBvzofkIbuCteSZJ7oVDg+vXrTE1Ncfr0adrb7++MMbh/WVjz8/NcvnyZ/fv3c/jw4Vf0hbwrwdpWsFKCMpTdpf3lpzNIRARqVF6Q52RxidceF5TuPF7tMqjNbyCXFoyVSWnfb/OIR36kNkRdj4JYB0mcbi9KPbd4DeQFa7ZbtbOBLEExmRYFhpp9u4Q/CrxZRvcu26REafXa51Pf2cbYjRA3vqmg1hxOb5BQ1fpzVE+odo9duNvzdxurU7evws4iVWmHUJdKhPqW18YE/TAQrFoFK5lMvuocLL/fj06nY2Vlper+lZWVXWeuAvzH//gf+cxnPsP3v/99jh49+qrW8bDgR/cT2oAQJaO7TqdDVdWXTWa2tra4ePEi6XSa8+fP43a7X5P1vdoSoaIojIyMMDY2xsmTJ19WgrwIIoKVSeVZ2Q79jAjyrHSCkSP+FiuKoLswLTB4ewNOzfsNRomYcMi09ms22MXnNiXoOhTNTZQkyp2UWo9pwR4yCbO+hHli/l1+qQsa+8y7kEKRN8vgFKtu+U2xN0u4TUwQBVET36HzOlh3HOH5bzjYuC2yxavbeVY1JEdXfaLrc66Eyys9o/oouurztmvQaMVj+a3KLsLijEjjvvv/AwweToJ1P0blGI1GTp06xeOPP16+T1EUHn/8cQYGBoTb/Yf/8B/41Kc+xWOPPUZ/f/+rWsPDhIYH6yFG6Q84n8/fVWoOh8Ncu3aN5uZm+vr6XtMvt1dTIsxms1y7do1MJrPrUOl7WYsWwZq7HUdRVOwuA1FBbpRIDZJN4vT8jSVBkKWg687TbGVjRrsUmElokzV/yM3mdFTzMVHpUDTr0BE0kV4RJMILAkNtPiOZZW2ykhWs2ezSI5gqIywD7hYYKpqpqDftsk1ElJul/XxJL5GPC7bZJkmSyUA2tJ9Lj0rkU3kcLSbUmPbalEwOFQ0F665/ineJZai5nUmJM7aK5E77s6Dmd95vSaegYMAS8N9tca8IDyPBSiQS9yUH6+Mf/zi/9mu/Rn9/P2fOnOELX/gCyWSy3FX4/ve/n9bWVj796U8D8NnPfpZPfvKTfPnLX2bPnj0sLxfTfu12eyNZ/i5oEKyHGKU/4N3IjKqqTE1NMTExwcGDB1+X3JNXWiLc3NxkaGgIh8PBuXPn7kuOlohglQzu/jYbyVhUc9uYwCxtd5pZ1aALdreBpEBBygnmFjp9RiHBiovypAzaJMLkkMjGtY9TEJQu7X4xwcoI1DjRrEWAlMibJghsRVKF2whzs4yScLSPKDDU4DSgCLxeIonH5LXApigfrYC8bx83n7MQe3bn3Jp9BjIx7cMUNrNFBau2k0+WqCRJtR6rOgXrLopWIVu5vVq1fTFTq+rRinVUm9wLkunlyGevCA8jwbofJUKAX/qlX2JtbY1PfvKTLC8vc/z4cR577LGy8X12drbq3P7xH/8x2WyW973vfVX7+df/+l/zb/7Nv3nV6/lRRoNgPYQolctKHXsiH1Y+n+fmzZtEo9F7ijZ4tXglJcKVlRWuX7/Onj176Orqum8p8CI1beJasdPP4RJ4aQwy4Xlt4mMymEGDYHmbLSxFtXWahMAULirdGcwymwJvlij81NtiIxzXJhEJQYK5eZd09YSA4ImM/DqjJJzPqNSGX27D4jdREIyvEb1OS9BMflWbyFaqMJUw+0zkhFlb2n8/BreJvEbGqGFvMxOTHmZf2KI2X8Fk1wuHY2fWU6iqXqOTr8b0fjdPVo0EVjt2p5Ku1XEzqYZPVtyoJKeSrJLMGLl58WJ53p7b7b5vpOhhIFi10yXuF8EC+MhHPsJHPvIRzceeeuqpqtvT09P35ZgPIxoE6yGHKKohmUxy5coVjEYj58+ff127Ve6lRKiqKpOTk0xOTnLkyJG7GjVfyVq0FKwJQe5VCaEOGyuCIc+JDcElVCfueFsX+LxENNLbbGF9UpvgpQVlOKuALILYZ6U3ahMso00mJcjzEmU5OZrMpBe0X2d8XTsN3eozkhAQLOEwZ7eBvGAwcz4pILJOAzlB1lYhIRi0bdVTuQJjR4CZRR+TX83ha9Fem07wZ2Zw6ClspVFVQ30wKOKyHRqPyLUKZq3HvYqs7V5OrIqDqFSwdCDbA+zfv59wOMzw8DCFQgGPx4PP58Pv999zR28lHgaCVdul15hF+OZDg2A95NBSi0qjZNra2ujp6Xndv8hebomwUmE7e/YsTqe2EfzVrkVL4Zu8USRYm4IRLR6/WUiwwgISodNpXyS9LRai84K5hYI8KYfXKCRYIrJkEGRDGW0y2bj2+7G1KQjLDJmJT2kfPy8od1o9BiHBMuQNpKnfzuQQe7OyMYE3yyZW3bIC8qsTlSiBnEDdK+VmGTsCzK/5uPO1HJDbdbSPJCg3WoMmlOUEigq1HxNZkqrOzN2CRGtN8fWDo4Wb1kMzb0sBSUF2+vAGAgQCAVRVJZFIEIlEWF5e5vbt29hstrK65XQ67+l75mEgWK9VibCB1w8NgvUQonZcTolAVKpBL3eUzGuBl1MiTKVSDA0NodfrX1OFTUvBWltIEotkkCRYnhFc3iVtQuINmYkJCI5JZ0WrJc4dMAsJlqgMaBQFhlp2Kx1q3o27ycyGRuo7QG5LECvhNhDX3h1pUblzl3JjLqq9uN28WWmBB05EZIvDnAX5YKLAUJuBwpb2Z6Cgt7Bi7GN8m1iVYAuaKKxpK1iiKAiTS09qGU0PVnF2Ys1opd1Q81oUnTjjrFbBkqRqDavY1Vh6rPhZkHRKcQk+P9lsFlmWkWUZh8OBw+Fgz5495HI51tfXiUQi3LhxA1VV8Xq9ZcJ1t7/nh5FgJRKJBsF6k6FBsB5ylMhMPp/n+vXrbG5uvmZq0L2uSYT19XWuXr16XxPkRdAiWKXyYLDDxuqMtoKzvqpNL7wtFiHBiq5qX9xFg5ENJokNQelQVIbzNFtYn9TeRtTBZ/MY2UCbYClb2uc+UxAMUkbszRJ1ShosMmlB1lZ9CasIs8dEIan9OkUzDc0BE4pmUnrRlK4Fk89EYbWCYMkSpq5mJictzF82s3q13rFu9RrZXNP+3OQF8RH67eHcmsVApYZg1a++6lbt9ulYtRe9kjTthuLg550nltIddPriuTK2tyLLMqqqln/ESZKELMvodDpCoRChUAhVVYnH40QiEebn5xkdHcXhcJTJlsPhqPNUPmwEK5fLkc1mGwTrTYYGwXrIodPpSCaTXLhwAbPZzMDAwOueDlyL3TxYs7OzjI2N0dvbS0dHx+uyFhHB8oUsQoKVietAo6RlEWQmGcyycBSOKFrb12IlIijDiSIa7B4j62gfZ1NgMDeYtS9ksiyxKYhbMBmNaI3vsfoM5CMCb5ZgPqEtZCI1J1J8tLexBoxsCQhWIS3yZhlJRTQforAlmmloJLUKOqsB2lsYHpRZ+//yQJbmbsF7bXsFY3q2r7VaOVh3r+NVQ9012Orl77o0Dqf83O1wUZ2+mIFl692P3mRCURQKhQKKoqCqatXfdkndcrlcuFwu9u3bRzabJRKJEIlEmJubQ5ZlvF4vfr8fj8eDwWB46AhWMln8nml4sN5caBCshxCVvwbz+TxTU1N0dnbS09Nz37rvXg20fE+l8NDl5WVOnTr1ug0a1SJYIy8VB/GK5tnZnHpia9pkpZDXvrgF222s3tEmaylB3IHTZxQSLFFEg6jrUG+QiAsysEQEz9lsYmtBYH6XtA3zsjUPAhIjUtAsHgOpOcE2m+JhziINLRsXebP0AuoJuZigdGgzkd2zn+tP5UlfVKjsCkwJSrF6g0Cps+nIJbS3KWSKa1ZVuFdeUa947Z4cWvUdsEvuVe1sRp2eov3KKFEoyFwcHiUQXK8jRiWSpShK+b9Q/FuTJAm9Xk9zczPNzc0oikIsFiMSiTA1NcWtW7dwuVzk83nS6TROp/MN8Z11vyEiWK8216+B1xcNgvWQQlVVxsfHicVihEIhent7H/SSyqgtEWazWa5cuUI+n+f8+fNYLLt4Ru4zagmWqqqMvBQGYFPgJWre62T6alTzsbVF7ZAjp8fEqmDM8YZA2TKYxWpYXJjurn23u8VMbPreAlPtPjHBygiGPLsCdtbmtDsC48vaXiaDgBQCpAUkxrCLKV2kEolysyQd5Cq8WbJJh2F/kOk5A8uTVuafrx/ObXLoyAqIsah+awsaUVa1aWFyu4uyqGDdrQFkd4VKESiF94wapidvf7h0Jj051UZPby/hcJhbt26Rz+fLKpTf7y93yNWqW5V/azqdDkmS8Hg8eDweurq6SKfTRCIRotEoIyMjjI+Pl0uJHo/nvmTfvRGgRbCsVmudL6uBNzZ+ND6NDdwTcrkcQ0NDJJNJQqHQG25oZ2WJMB6PMzQ0hNvt5tSpU6/7F2gtwZoejrG5kUVvkFiY0PZZWQVdarIO4ivapU9RB5/VqWdT5AsSZDb5Wi1ExgWlQ0HXod1rFBKsLQGRNO/SjZcUKGhmqyAKQobshjYxkAWHMdhkMjGBN0tAMkweg9ibJRzmbEaNZ7Hs9RKTHVx/PkPyWgEo0D2gTfbtAROpGW2CVUgL5iC6DWwJ4iN0WYk8RQXrXkff1EJBHI9Qm9QuyQhJeSGrUrWr7dKjCqgGB8FgkGAwWO4gDIfDLC0tMTo6is1mw+/3EwgEcDqdmuqWVinRaDTS2trK7du3OX36dJlwjY+Pk06nyzEQPp/vTa32KIpSR7Aa5cE3HxoE6yFEMplElmUGBgaYmpoilxNdpB4MSgrW8vIyN27cYN++fezbt++BlAJqCdati8UrYFuXk5kRbTUqs6V9AQ20mwlPCxQfAfEJtNuYj2kTuZRAJbJ7jEQEBbKEIPXcJPCGSSAsHcqCWYtGmywcAC0SV6wBPUpYQEiy2ufGFjKTmtNWvRTR0GyfibSAYCkZDc9cuwO1xcPYSw6Wv5uDmiJiTvC+md0GUjOaD5EVkEKDVaC6ySqF7cgJlbsb0GtjGmpPeSoqJmm19+sMMoWM4E2rKDWqqlomWEq+gGwLVOxTKncQ7t27l1wuRyQSIRwOc/XqVVRVLStblR2EtepWpW1AVVVkWS6TKSjO6it5t8bHxzGbzVUhp28W9adEMmsJVsPg/uZDg2A9hPB4PJw4cQIokplUSuQ8eTCQZZlkMsmNGzc4evRoeYTDg1pLJcEafrFYHjRYxWWYtVltcuNvtgsJlij13bZL+GdYcByjYJ6e3iQTFcw6FF2zHU0mUgIju4jEuJotxCa0y505Afl0Ba1shLWJZHRFm8ia3WJvlmiYs9GpR1A8JbdZJDGWDidZl507twvMPptm/1mZ5Snt/QkjJyziEmVaONpH+/kWvxk1WdxGVTXS1eu2uMfZOLtANkjVBEvwsa803qu5PJJbPIPQYDDQ1NREU1MTqqoSi8UIh8PMzMxw69YtnE5nmXCVOghLXq3SD6+Swb0yBsJqtWK1Wmlvbyefz7OxsUEkEmF0dJRcLlcVA/FGU+0rUfq+qSRY92sOYQOvLxoE6yGHKMn9QSGfzzM7O0smk+H8+fM4HI4Hup5KgqWqKt95YQLjXoW4nGD/WRe5BKzNJEltG7T9LRaiAl+S6ELn8puIi7KpBOUZb4uZzUUB8clpXwV9bRYiE4KIBoES4wqKCVZaoMRYPQYE4/RICQiJySH+KtKlDYDGdnqxlygdEaSra3izZIOMtctFwmpkbM7MyjNZqPDDiUzpkiwuhYqGY5scOnKCtHgE3iiz10B+ezlaXYR3HeX88psGqQ2CkOq4unbKe+WadPoC+pf5o0iSJNxuN263u8pjFQ6HmZ6eRqfTValb4XCYiYkJjh49imm7Q1ErBkKWZQIVIafJZJJIJMLKygq3b9/GarWWyZbL5XpDdSSWvo8bCtabHw2C9ZDjlcz9e62wtbXF0NAQkiRhsVgeOLmCaoJ19dIic7NxdHqJlbCerWQUKF5y2todtIYcNAeteJrNbCwmia/kqRyhtylQLoLtNqbDUc3HtgSJ394mi5BgJSLa9zt8JiHB2hR5pnYZzBwXqGEGQcipJEFCQNZEPiudQSIliI9IpbUVPL1FJisYml0KDLW02SBgYzUOw9eSqIN5iAmIsYCg2P0mFMF7KoqcsIZMZOcFHaZpgepm3xm5o6Vg3Q2SXqeVX1veXyW3qA0S3a0cWdVsWPH+6fV5DO2vbCi82WymtbWV1tZWFEUhGo2ytrbGxMQE169fB6CtrQ2r1Yper69Tt0QxEHa7HbvdTmdnJ7lcjo2NDcLhMDdv3qwKOfV6va9qhM/9QKFQQJKkKkvE1tZWQ8F6E6JBsB5CiJLcHyQikQhXr16lpaWFYDDIjRs3HvSSgB3DfSKR4C//7HkA+g76GLm+kzWgAnMLm8wtbHLidIDrV7bLiAaZzr1OQj4bdpMBXVYmVLARmU+RryivmW0C/5MEqzOCgdECz5QsS0TmtEmUKFbCYJKIiUqHgh/2FpeedEzwuRHEANiDJjKCkFXRYGZbk5nMona50WF1kKa+g8/o1aGEK8iKBLY2G1LQQljScxMXkctZYKebsanLQjR2b6N9bH6jkDTnBYqgxaUnO6/5EMmw9uvUm3b+XrVDQHeXqFIpY7nD715R7+eSNB/TGSu+U4w5TPs7X9HxKlHKv/J6vczMzDAxMUFrayvJZJKLFy9iMpnK6pbH46lStEpkSxRyWmnA39zcJBKJsLCwwMjISFXI6YOIgSgUCuXIihIaKe5vTjQI1kMKSZJQVfWBK1iqqjIzM8OdO3c4cOAAbW1txGKxlzWL8PVAiWBdvHiR4StFEmK1iX1R03d2hkDncgrjU1HGp6IcOOJj7EaRDOhkidZOB01+Gw6LEdkh0X7ESXwlQ3wtUy7p+NutrM8IDNk5wSieVguxWUHAZlb7QuxptbAhULbyaZHPysx6TOCzSmoTL8kqJvK5hGA+oddAZlF7G1HqueyUUKw6MkYdmxkdczMFNq+lgTQdvU4iy/UKktVlICpYW0ZAJC0OPdqBE5ARKGgGQSo/kkpe0BhQWW1UNWOpau6oeZvzGRWj+CNbt47qWThK1f7Vyjk7FYfVGbY7CLclMZ3D/TIPeHdMTU0xMzNDf39/ecJEoVBgfX2dcDjMyMgI2Wy2KgaiFOVSqWyJOhOdTidOp5O9e/dWhZzOz88jSVJ5v16vF4Ph5Z7IV47GHMIfHTQI1kMO0TDj1wOKonDr1i3W1tbo7+/H4/GU1/RGKFuqqsrS0hKKouC0dTI+OgbAwqz2ZTXQZGB9WftcOpw76fgFRWV2Ps7sfNHU7fNZ2Nj2DFlselqb7Pg9VrxBC642E4WUSmojR2w5Q3ZbTRGlrruDJiHBSgr8Tw6vSUiwtgQREVaXQUM72t5mXZsoWJzaA5sBUoKypnGXKIhMLIetw4rBbyJjkIluFZiZS+E12Zi8vE4xSb/6eDHBOCJRYwBAQhgYKmrFU8XeLMFh9E4ZRLFZuYruOaRt5Uisqqg1quO9CDASNfyqZs6hUtghfFUKlmHn3zn1/sQjlGajzs3NcerUqSrLgE6nq/NYhcNhlpeXGRsbK8dA+P3+ssfqlYSclkb4zMzMMDw8jNPpLKtbdrv9NVG3tAjW1tZWg2C9CdEgWA85HpTJPZPJcOXKFRRF4fz581VdPSXVSFXVBxLNAEXyNzw8zMrKCgA/+Jvi//cd8nL71obmNh2dHtaX1zQf2xAQiNZOO0sV43ZSqXxZ9eo/38TQxeWq53sDZlpCdtK2As3NToySDFnIJxVS0RymXcqNG/OiwFKBiVuC6ILALC4wfss62BSUG+0OKxsaPXyyHrZEhEQvYWsxY/AZwaojq5OIpfJE4lmuTG2RzShAdVRDYK/2hchgkkltCNQ1gSnd7NAJQ1MFm2D1m1DWBaVQgfLoDFnIC851vsIU/3I8WFLNxfnV/Amp+QKVBKtqVxU35O0xOUig6F/9HNNSEPLi4iL9/f27kgtJksoeq9Ig6ZJR/tq1a6iqis/nKxMuUQyEVshpyYC/f/9+MplMWd2amZlBp9OV93s/Q05Fg54bHqw3HxoE6yHHg1CwYrEYV65cwePxcPjw4bovk9LtB0WwstksV69eJZfLcfr0aZ566jm+9ldF9coiCsoEtjYFXh27nuk7Uc3HQi3VBKsSGxqJ4+vraTwhC8OXtetmR9uCzLgT+L1WXHYjdosRk0GHzWJASgF5FSWjkk8pZLcKZJMFFIH/yd1iJiG46Is8U84mM1uL2tso22OCJJ2EyanH6NCjt+sw+QxIqkpBhqyqksgWiCezhNczxNIZbs9uwmz1voKdtm1yVY+8ID7C3WwhNq1NMhNRgc/LbyKxKSi5Co5v9xtJCAhWfkv7b83s1pNY0HyIbEWKvKJK9Qyr5q3IqUZEctjLCyqtQOVLlGqM7RWdg7JO2W5AVFFtr26Mlaqq3L59m5WVFfr7+++ZWNTGQMTjccLhMHNzc3UxECWP1csJOTWZTLS0tNDS0lI24EciESYmJkilUrjd7qqQ01f63SUqET7IuJoGXhkaBOshRcmDpdfry7/eXo9W5cXFRW7dukVXVxd79uzR/BIqfbmUzJ6vJxKJBENDQ9jtdk6ePEmhUOD5H8aJR7O4vSaGr4U1t2vtsHN7WLto1tXr5cagtrIlIiomi47ZCe2wA7dH3OW0trjFZiLHZqJ62yOnAowMag8B3BPLsGTdxG43YDHpMVsMmPQytOqRmozodTI6WUYnFT83EpBwKNjfsq0qqKBKxQuj3mVA3yaT3EqzlclgMJgpKJDOFEgXtphypNnaykOc4n+B7mMepq9qv1a7RzuvyOExsDGtfQ7SwgBWg5Bg5ZKCrj+3gYRgQmFWcByzU492/CnC7kat+AgAnUkmF90x32spWHWxDAW16jn36zeKUvP7oYpgSfniQmQV2SvOwLobVFVldHSUcDjM6dOnX/VYLEmSyoOkK1WotbU1ZmdnkWW5TLa8Xu9dQ05LRvmSN8vr9dLd3U0qlSqrW5OTkxiNxnK0xL2GnDY8WD86aBCshxyvF5kp/Sqdm5vj+PHjBAIB4XNL6ygUCq+LqbSEUrJ0R0cH3d3dFAoFNiIpvve1IhMIhGQm1rUvxK1tDpZntVUQUSYSwOKs9qV4zz4nd25qlyJFA6OdLiMrC9prMAnmFsqyxPJsgmxOYX0jQ2U/vzlg4Pp17dktLoeJZLyeLBwbCDI8WElCd9QXdyJbJFc1EI7PAaKCmYpmQRclwKbAM2WyiLfJaWecks2LRkZD8h6HOUuyytaaIBVf1K0ZMMFGcQ3F5gcNBav2ODVPqO0EvMvGVYytyo+l1uy3skS4TbZkWUEfann5x6vav8rw8DAbGxv09/e/JjNHtVSoUrbWjRs3cLvdZcJls9ledgyExWKhra2Ntra24vfGdsjp2NgY2Wy2aoTP3V6XyIPVKBG++dAgWA85Sn/I+Xz+NSMzuVyO69evk0wmOXfu3F1/iZV+Ib6e3rDZ2VnGxsY4ePAgzc3N5HI5CoUCf/LH1wi02vD6FaZvC4YRGySmx7UVGItNz+gNbeVob7ebmTuC4c9usUq1uqRNolr2OLh9TVtFy6S01ZZQu5VlQRSEIohbcPvNJNa0ze/JhPY5sjkNwuHYIv5ptutICLYRlV9MFpmEwJgvIjF6oyQ085stZmo9XgBGq0xa0PUnIjRmnxF1U1ByzWt/1k1uA9ltnl3qLq3LaTcaqiuCtcmi92Ryr4llUMQbVz1X1kEBZJ2KsfPeM7BKDS+bm5v09/e/LknrlTEQPT09pFIpwuFwmXAZjUYCgUBVPlalX2s3datE0lRVLY/wWV1d5c6dO1gslqoRPrU/bEUerIaC9eZDg2A9pChdoCRJek279pLJJENDQ1gsFgYGBl42idPpdK9LVIOiKIyOjrK8vEx/fz8ul4tcLoeiKPzfr4zxX/7LEAaDxKHDAZrtZqRcgdgKxCsu/Pt6LIzf0i4j9R32ce1FbRXIH7AICdZmVPuC73QbWZ7TJlh2h1HzfoAVwSgeX1BMsDYFIafBZquQYGXT2uTC32JlPq4tE2UFOVP+JitrgqHVeY25gQDukIXYlMAzJUi4dzWZSc4IQlMl7c+rwakgmrmjCLxZkjWHKNehkBSEjNp05Qz7ncJfdRdhIi5h0leMqlGUVzwcR92tO7H2jooSoaJIyICsK2Dq2nNPx1QUhRs3brC1tUV/f3+5TPd6w2Kx0N7eTnt7ezkGojRq524xEJUerhJK6pbNZsNms9HR0UE+ny/vd3h4mEKhUDXCx2QyNUqEP0J448wHaOCB4bUiWGtra1y4cIFgMMipU6fuSSF7PaIacrkcg4ODrK+vc+7cuSpy9dwzC/yr33kGgJOnmrh6ZZWbN6PcGNtkLraJv9fK4bcG6D3mZWNVXILZjIrG5sDSvLba43QZmRjRLg92drmE+8ukBaTDZ2J9VdBBaBSkrgPLgvKl1S5+HzNx7Qu0fZeZipsC9cjuFl9otwRjeuwe8XHSm+Lh2CJkBNt4msQXu6xgG6dfXOLJrGuzNV3Fy9kRpmpKdbWKVdUQZrFCqIU6BasyV6LmMHIFwSqU8tL0BnSWl68+KYrCtWvXSKVSnDp16oGRq1qUYiD6+vp461vfytmzZ/F4PKysrPD888/zwgsvcPv2baLRKDqdDpPJhNFoxGg0otPpyrEQ+XyebDZbVsRlWSYYDHLgwAHe8pa3cPLkSRwOB0tLS7zwwgu89NJLbGxskM/ni5li27hfMQ3/9b/+V/bs2YPZbObs2bO89NJLuz7/q1/9Kn19fZjNZo4cOcJ3vvOdV72GhwkNBauB+57mrqoq09PTjI+Pc+jQIVpa7t2TUYpqeK1QUtasVivnzp1DkiSy2SyqqvLs0wv8+iPfIZMpcPZcMy9eXKraVlVh/M4G43c2OHO2mcVMkr7TPqwGA6szSdYWiqrLnm4rk2PaCtWeLhez49qKzr5eN9cFqpdeL/5NtDijLY80tzu4E7m30mGw1UpkQZuUia7XZpuODUHOlGjdsiQRWdI+jsg3BhATJMKbd/FZJUVlwF38XFuCpHazTUwE4oISrtlm1BSwZKMkJFhUqLglD5Skk1Ar/zRqc0YrOgXvaQwh9QpWoaAT76XiqUpOAQNgfvm+qUKhwLVr18jn8/f8A+z1hFYMRCnk9MaNGyiKgtfrLZcTS6N2Xk7IqcPhwOFwVMVLTE5Osra2xrPPPssPfvAD2tvbicVir9qD9X/+z//h4x//OF/84hc5e/YsX/jCF3jXu97F2NgYwWCw7vkvvPACv/zLv8ynP/1pfvqnf5ovf/nLvPe972VoaIjDhw+/qrU8LGgoWA8pKj0s91MtKhQK3Lhxg+npac6cOfOKyFVpTa9ViTASiXDx4kUCgQAnT54EimqWqqo8+q0pPvgPv0s6XeD02VAduarE6TPNvPTiEolEjsuDyzxzcY7RpXWsnUb6zvsIdbgxC5K7HU7xRV004BlgYVqbRLXvdbAhMFDbdkmeDy9rkxtfSHyh3BIoNMEWm3CwsCg6wdNsFj4m6rC0OvVCBUsWeLMMJlk4b1HWaW+jN0okBaVQnUAWMlhlCgnBSRC8sbagSchhlExFyOj2c9K56q/t2pdcdfNeGVYNROn/xeMqFf/eNrm/TBJQKBS4cuUKhUKBkydPvmHJlRYMBgOhUIhDhw7xtre9jZMnT2K325mbm+OZZ57hxRdfZGJigs3NTfR6fVnZKqlbJeN8Sd3K5/PlsmBTUxMOh4O9e/dy7NgxVFXlv/23/8by8jIf+tCH+NSnPsXg4OAr+m78/Oc/zwc/+EE+8IEPcPDgQb74xS9itVr58z//c83n/+f//J/5yZ/8SX7rt36LAwcO8KlPfYqTJ0/yh3/4h6/2FD40aBCsBu5bFlY6neall14imUwyMDCAyyUuZ72cNb0WCtbc3BxDQ0P09vbS09NDLpcrk6vPf+4yH/pH38NgkDn/1iZi0U0cDm0idOx4kKtXVgTHiFOQVL7z5CTLhS1CR+0cfKuf9l4Hkqzi9hoYva6tKDmcRu7c1H6sY59TSIiCzeILm1a3H4Dbb2JtUdvjZNlF1QkvaW/j3CU+IiEgRB6fuJyU3dJ+/z1NYvKXF/if3M0WIflTBATP1WQWb5MXZGAFxecgFolq3m/xislFfrNI8CS9hLq/CQC1pvmgzvReOVpHuGcBal7wyx32LMvbGWeOu4eM5vP58lD3kydP3reAzgeBUgzE/v37OXv2LD/2Yz9Ge3t7WSF/+umnuXnzJqurqyiKgtFoxGw2YzKZ0Ov1yLJc9m6VCFeplOhyufi93/s9BgcH0el0/Mqv/ArXrl3jx3/8x+np6bknkpXNZhkcHOSd73xn+T5ZlnnnO9/JhQsXNLe5cOFC1fMB3vWudwmf30A93ryf7AbuG+5Hmns0GuXKlSv4/X4OHTr0qiMf7neJUFEUxsbGWFxc5NSpU7jd7rLfKpNR+PjHnuBb3xzH5TIRCBp54bligrpeL3PosB+n08jMdJzFxQQnTgYZHo6QE6Ry793n4uqVYokvl1O4eXMnA8vtNtF9xs9WLMfqdJJITep5Z5eV4cGo5n6DLTbmJ7UVLJH/Sm+QmRUY6Vs7HcTC2h2OGQG5cflMxARlM4NgmDRARETkdvFzxQXHsbsMaBdQYUtgzHf4jMIMLFFuls1jZGtWWxXMJQTzCd0GMnPaazNjIUt9+VAyij/n2fUUpmY740kXk0+maDLcnVBVK1i1w29qN9bY2fbTVVU87Lv41J39SnLR5I3bI96AolI8NDSEwWDg2LFj95QP9WaA0WisioGIxWKEw2Gmpqa4efMmLpeLQCBQFwNRIlmpVIpEIkEwGCSbzSLLclnheuSRR/jt3/5tstksY2Nj9/QdGw6HKRQKdWGloVCI0dFRzW2Wl5c1n7+8vKz5/Abq0SBYDylqS4SvRsGan59nZGSE7u5uOjs770v6+v1UsHK5HNeuXSOdTjMwMIDZbC77rdbWUvz6rz3G1SsrtLU7yOWyjN/ZITH5vMKtmzu5Tu/4iU7S6TydHS5u365XmkJNNpKJHOm09vlsarLxgx9MlyMQWtrs7Gl3QVZl4U6c5Tlx7pLIdC7rJGE34t4eF1O3tB8z7uJxWhF0Krp8MkntrFWh4uRvsbAhSHcXGbCNJh3rAm/WbkROdByjeZdZg4LSoWjsEEBK4OfKKtprBkgL5kdm89rbGF0G5P1efvj9LJlUCmNpBqC0i8okSVUq1N0ULJ1BQq3MVatNeBD+KatVj+l0CqoEkq9JeKxsNsvQ0BAmk4ljx4697iHCrzdkWcbj8eDxeMphpLUxEJUhp6qqcvPmTfx+P6FQCFVVUVWVO3fuAJS/o41GI0eOHHmQL62Bl4kGwWrgFStYlarQiRMn8PtfeYJzLe6XB2tra4vBwUEsFgtnz55FluUyuRoZ3uC3Pv4ENpuRc+ebuXl9lURCfB7On2/licdnyrcDQSv797vZSuUZubVGIGBDkmBhWRCjYDeQTRWq8qUWFxIsLhSJ0+mzzWysp+nu8pKN51gcT5Dbjj3o2G9lfkKbYPUd9TF6RVuJcu1StosJxrn4myxsLGsTFZNgbiFAZFHg52oSE6yUwM/lb7MQEQygVkRxC34TmTVRNpUgN8sqC83vouu/To9wmLNO4OcyOnRk49rHcTkcrNdkPshBPQtOO5Pf3Lm/tOdaUlp5W5IlEHjXtCAbJAoVb0F1sOju25aN9KqKLKuoMugFnstMJlNuKjly5MiPPLnSQm0MxMbGBuFwmLGxMdLpdDnSobOzs9xNubKywiOPPEJ/f/+rGpXj9/vR6XTl2aolrKys0NSkTYqbmpru6fkN1OPh+5Q3UIdXohaVavqRSIRz587dV3L1StdUi/X1dS5cuIDf7+fkyZNIklT2W/3g+7P8nZ/9GtevrZHL5bj04hKyLHHmbDMnToYwVygeZrOOU/1NvPBC9bC4tdUtLl5Y5PrVVbp7vHR0OmlpteN01neY6XQS3fs9zExrdw46nUYmxoudic9fXODS8Cqrahr/YSv7z7lwhgzoBdU0gyA5HGBTEIZpMMnMT2ivpald3A5u1Fs173e4DEQE/rDduvQ2BNu4vGJvlsjg7g6JyWRO0C3pComPowqInLPJLGxEsJq0/WG7ebOUCrVTb9UjHQ3yxKie8Eb1QUo8qqokeBcSdFeSVCPsvRL1uWR2l406HD31BCudTjM4OIjdbn9oyVUtdDodfr+fvr6+8kggq9WKTqfjS1/6En19fTzyyCP8+I//OCdOnODixYuvyqtmNBo5deoUjz/+ePk+RVF4/PHHGRgY0NxmYGCg6vkAP/jBD4TPb6AeDQXrIcWrKRFubm5y5coV7HY7586de01Mqq/Wg1UqW/b19dHa2lo2kUqSxBf/6Bqf/r2iUfNUf4DLl4qOnng8z0svFrsGzWY9J06GMJl1pFMFBi+LfQdHjwWYmIiSTBQv/FW+rZk4qytJThwLMXRZ2xQP0HvAx6UXqzsWczmF4eEIe/Y6mZvdRG+Q2d/rwm6SSUVzrM9k0Rtkxq5pq1e+oIXJYe08rb09bu7c0H7MuEsJrhRBUYtQh52ZG9qlyILAq2ZzGogKlKDd1rCxpK2GWR27DOIWEE2bx0hcMGtQlIFl8xnJChS5nEABtXgMZATDnHPxLJIsYTnq54WrGcI/KBJfj8dBnPoydOWZqR3eXOfBugtqCZWi05VztGpH41RmclX7r0rbGjG6q5stUqkUg4ODeDweDh48+ECGt7+RkcvluHLlCg6Hg8OHDyPLMl1dXeh0Oj71qU+RyWT47ne/y9/9u3+Xd7/73bznPe95xQrSxz/+cX7t136N/v5+zpw5wxe+8AWSySQf+MAHAHj/+99Pa2srn/70pwH42Mc+xo/92I/xn/7Tf+I973kPX/nKV7h8+TJ/8id/ct9e/486GgSrAfR6PZmMOBCzEqurq1y7do09e/bQ1dX1mn1hvlIFS1VVxsbGWFhY4OTJk3g8nrJJNJ9X+fznXuKv/7/bWK16OjrtDF7WHsKcTueJxzIkFnOsrW5x8JAfl8vI3Fyc+bmdUt3Zcy0MXl4mX9FVVunbslj1nDnbAip093q4c3t923i8g3PnW7j4wqLwNTldZgqFOIVCgeGKgdImk46zZwIkYhlysTyxBYV8RRVqT5eLa6vadnDbLqnvogR3l8/EukBxsmuodiXEBDP7Am1WFmLapn1R6rrdY2BrXZss6XSCGYBATEDKTBaxN0uYgWXfxZslagCwiAmj5LMwmTQx8b3qc1HnP6f4+d6tS1BV7pFgUU1+c2kwCE6Jzqi951IHoWKoVjdTqRSXL18uKzUNclWNUtCxxWIpkysokt6/+qu/4m1vextf/epXGR4e5tFHH+XP/uzPSCQSfOxjH3tFx/ulX/ol1tbW+OQnP8ny8jLHjx/nscceK5ceS8OvSzh//jxf/vKX+cQnPsHv/u7v0t3dzTe+8Y1GBtY9oEGwGnhZZEZVVSYnJ5mcnOTw4cM0Nze/5mvK5bQvpCLk83muXbvG1tYW586dw2KxlP1W0Y0Mv/GBx3jpxSWaW2x0dFiRpBx79zmZmqwvlR0/GeL2aKQ8nHj41o6ze89eF83NNixWA0/8cKZu2xJ8fgter5kXnt+RLgIBC/u7PKRTecZuRTh2IsSLF8Tkqv9sE5df1FbPVFVl9Hac1ZWiqqTXS7Tvt2K3SMgZmeiGYC4LsCjI07I7DcwIwlFbOhzcCWtHSKiCAdQ6vcSqwLi/GylLCkier9nC4rqAlAniFhxBE+lVkTdLG0arTGJVlIGlvY3eJJES5GbVluIAXIddzCHz0vejmtsUMtolwkrUhbjnVeR7aMyrj3wQ1xR1BnVn5mGl72tbzSoYd9SrZDLJ4OAgoVCInp6eBrmqQT6f58qVK5hMpqqy6ebmJj//8z+P3+/nq1/9KiaTiRMnTnDixAk+8YlPVKW7vxJ85CMf4SMf+YjmY0899VTdfb/4i7/IL/7iL76qYz7MaBCsBu6a5J7P57l58ybRaJSzZ8/idN496+bVQqfTkU4L0q01sLW1Ve5QOnfuXJWZfXIizvv//reZnYnT2+dhaWmTpcWd19vcbKNzj5vEZoaRkQinzzbz0sUl4bDj1ZUkHo+ZCy8s7hjdt3KMDIfJbSsve/e6SKfz3LldXYZbW0uxtlZUgd76t9pIpfKcPNPE+NgGsZqxOnv3urh1XdCyB5zob+LFCuUrn1eZmkpub+tg+M4agRYjPrcBq85EOgwbS1na9zuZn9AmKXt7XYxc0i457paSLlK2mvbYWR7XNueLwjolEKbIW53iMmAqKvBmBU0sCwhWXjAH0d1sZlNgsk8ntVUqR5OZjGDmo7pN/iQZnMc83N7I8eSLG7T3if+WMjXxEVL5fyr2S00Mg1r7eP3tyl3UEiy55rlVj1U8WEnEJLn42gpGB1AcTDw4OEhLS8trqnK/WVHKAdPr9VXdlMlkkve9733YbDa+/vWvlxPhK9E4l28uNAjWQ4qX68FKpVLlL4OBgQHNP/rXAvfiwdrY2ODKlSs0NTXR19eHqqplM/szTy/woQ9+j83NLCf7g9y4tlYmQSUsLSVZWkqi10ucPddCLqdw/ESQkZEIqa3q8xIKWbE7jFwZKvqp1la3WFstXlTtDiNHj3mxOQyMjayzIugmhGJH4nPPzpdv63QSvYe8uN1m5uc2QVXZTGRJCczZLa12bl7XLm8C+P12ZqcSrCxnWVnOwnb+ksOlg5CRNo8FdUtmbSpdNWw5kxbHDIhiE1x+E8sz2q/VGzALCZaog9DXYmFzUaAe7VIG3BCQMssu5VDR0Gqb1ygkWImwNomy+gxk5jUfQskr2M/4uDqZYO65HQJrcxg0XFaltVUTOUmqj2ioFTTueTROTqGSVkm7MKxKUiVXzLCUtwmWYnexubnJ4OAg7e3t7Nu3r0EIalBKsNfpdFXkKpVK8Uu/9EvodDr+5m/+pjxMuoE3NxoE6yGGJEmoqiosEa6vr3P16lVCoRAHDhx4Xbt/Xm5Mw8LCAsPDw/T09JTbn0vzv770Z7f4D599kZ4eDw6nzOWXVurIVQlOp5GOTldVOc9k1nH8RBCTSc+dO+t4vRZisQwT41HNfSQ2s+j1Mi88u4AkwdGjAaw2A1OTUVa2y3hGo8zRY8G6jsRCQWV4uHjh7dzjwm430uo04Q9YGBtZr7qQGo0yDqexHO9Qi45OJ9eGtA316YzK6FiC6HYJTqeD1j02QgE7ha0MyXQOSa6f6uL2mVgQhJy27XFwW1A63G2M3fKU9vp9LVYhwcpuaZMyd7OF1KJgFI7gYyvrJGKi3CyTuM6mburYqZVVbKPh53IfchCzS/xwfJOoRslRZOY3WmSh16xqLa/yCZUKlqKCflc+VDEXUVdJsLZT3L02BgcH6ezsZO/evXdb2UOHQqHA1atXkSSJ48ePl0NWM5kMv/zLv0wmk+F73/seVqt2p24Dbz40CFYDmjlYc3NzjI6O0tvbS0dHx+u+prv5wlRV5fbt28zNzXHixAm8Xm/ZzK4o8Ml/9Rx/+aWbmM1FL9fTT66j00scPhLAbq8mPe3tDpAkbt6oVoQy6UI5kf3UqRDpTIH9XR7MJh1zczWGZAnODbRwoaJkd71CYeru8RBqsqEq8PxzApkDOHDQx+JigpnpHR+U12umq9tLIVfgzug6vQd8wo5EWZKw24wUBFlIx04EqzxdhQLMziaZnU2yZ5+ZuckMFouOPXvd+NwWdLniDL+moJ2RsHa50mgUkxFR6TDUaSMiSFY37xKAKsrT8jaZWBAQrJxo5E6LmaQgqV1ETEwOHZmYNsmTt0uejj1WlBYjN2bizN5YxWzTI2tzSeFxPCELW1PV50erRPiqZw3qZEojBe8a6VDxgyedkigJgyUFa0ndoGtvP52dna9uUT+CKA22VhSFEydOlMlVNpvlH/yDf0AsFuP73/8+drs4IqWBNx8aBKuBqhKhoiiMjo6ytLTEqVOn8Hq9D2xNIoKVz+e5fv06iUSCc+fOYbVay36reDzLhz74A559Zg6/34LNLnNje+5fIa9Wkaiubg8dnU5WV5LcvCH2Og2cb+XihYWqC1DnHietLQ7Wwinm52L0HfBXkatapFN5pidjzM9v0tpqp6PTRSyeYXQ4TOm6dbK/iVs31+rG3qyvp3npxUV0Oon+003FQdQDzUxPRFlbrb4InzvfwovPa69Dp5Pqnl8Jl8PGHBlSqQIjw9U+rLPNMraDRkIeK0ZVRyqaZ3UmSSqZZ2NVMGTaaWBFUDr0NVmFBCsn8EVZnXqiggBUi1XszdoUlAGdAZOQYIlG4biazCQnql+TJIOn107SITPTqWdqMgKTO4/7mixsjAteq4D82T0GbYJVg1oP1r3yrWxaxqTb7gK821idCtKeTSmwPWpU1ikoEux7y6EGudKAoihcv36dfD5fNXsxl8vxyCOPsLS0xOOPP/6qZrc28MZEg2A9xCiVCEsKVjab5erVq+RyOQYGBh6oVC3yYJU8YQaDoZzBVSJXMzObfOb3LrK8nKCry01kPcnMtLjM4vVaePbpOXI5hbY2B20dDuKxDCPDEVS12JV3qr+JCy/UBxjNTMeZmY4TCFjo6fVhMuk4eizA8K0w+ZqOuoOH/SzMb5ZN7AsLCRa2y3tuj4meHi9Op5EXnl8QzhS0WPX09Hp58eJOVpYkQVePh0DAytrqFh6XmUsXljS3B+g/21xliq86Fz4zY8NRzcfMZokrQytkswo3K+6XgAOHfOTMCl1v9SDlJLbWc6zNb5FNFWjd72DiinbWll6QeA5ig3uw3cZCTDscVRUodnqjTFSQML9bRENSMNbG6jaQBBztFoztJtYLOW6OR9kYW2av4mJhqr6M6nAb2RBkbYnyubTWJgGSXGu6ujcTVl30Q6U//i7bKoqCrOGpkmWFPEZ6jvbtvoOHECVylc1mq8hVPp/ngx/8IJOTkzz55JN4PLvPcGzgzYkGwWqg7Hd64YUXcLlcb4gJ91oerGg0ytDQEMFgkIMHD6KqKplMBkmSePHiMh/8wHeJRjMcPxFgcTFGa6uFlhYXoyORupLZwPnWKuI0P7/J/Hzx4uj1mjlwyI/JJPP8s+Jy3v79bhKJLNeu7mRNORxGevu8qMDYSIQDB/1cu1okJ1qIxzLIssQPfzBTDjc1GGXu3N5gY72ornh9Zvx+K9euVGdaqSrcubPBnTsbHD8RZHE1wfGzIbKpAreHI1XH7Oh0cuOqaEQy9Pb6eElAvg4eCTB0qX5bFbC5jVyoiZmQgJZWB1KTxJ63uDEgU9hSSKznWF9Kkc8qJAQxDE6vUahS2XbpIBQRFV+bhY1JgWonIBQ6g8Tm8k650ewx4OwwozhlEk6J0UCe8MIa1PBuUROASeDnkoCY4LXqNIxjEqCrSe2v6yKsuX03i3llI+fd1K/qkYcVhnedQkZy3GXrhw+KonDjxg3S6TSnTp3CYCh+fguFAh/60Ie4desWTz75JD6f7wGvtIHXCg2C1QCRSLEc1NLSQnd39xui86e2RLi4uMitW7fo7u6uMrMD/NX/HuF3f/sZ8nmF02eCXL60iqrC6krxIu5ymejp9VIoKExNRdm7162pSpVgseqZm40zOxPHatVzqj+ILEuMjUaIb8+TO34iyJ3bGyST1Rf2zc0sly8VPU7n39pKYjPLiZNNTIxvEA5XX4BtNj1d3V4ubhOUdDpf7k6UZYmDh3wEAlai0UwViatF/+kmrl1dJZdTih2IgM1m4MjRAEa9jpWlBAVFLWd61aKt3c6VS+Kk+i1BGQsgvBKtu08FFpY2MZhlZqeqFSdZkmjvdBA2Zmg6Z8diMKBTJApphUyigMtrYuZSlIIgV0uEjXltcuPwmYQEK5fceV0Gqw570IjJa0DvkolEYsSzBcLxAqurMbhVfN6JgRDhSD0pcnqNpCLa51dStf+enH4TuTXtbZSMNiG/++8edZdbGmurIEq1ye27b1jaTkWnU8ioDWN2JRRF4ebNm2xtbVWRK0VR+OhHP8rly5d56qmnCAaDD3ilDbyWaBCshxilSe3T09MAdHR0vCHIFeyUCFVVZXx8nJmZGY4fP47P5yub2VUVPvv7L/JHf3gFg0Hi+Akfl16qJyKxWIZLLy0RCFhobrajKHDmbAu3b0eIblQbow8eKprMS/dvbeXLY3L0epnDh/00tdi5dXOtjlyVUFxLEy88t0PiJAl6er34fBYWFjZJp3I4nCYhcSplcF29skoslmHPXhctzXbCkRS3x3Y69gbOt3DxwmJdeSeZzDE4uILDYaC1zYGqwum3NDM/s8HS/A5B0MkSHreFpTltr9TBI36GBf40t9fEwoy2EtXUYqsjVwCKquLwGrlyTdukf+YtzdxQI3h8JjwuCw6rEatFj0mvJ+tQaP9bbmSkojFbUVGVIumQUlJFjUsq/kcGU1BP24ALZAlFVlEklZyikM4XWJEzbPRAZCPFRjRTVKQWoKPHxPKY9nsrjJYIWViIaHdZijxl7oCJsIBgpeP1x5ekYudjJe5OoGpum2SoUDbvRcGqxM52xWT5lF7P0tISfr+/TCYeVqiqyvDwMIlEgv7+/vLgZlVV+fjHP86zzz7LM88885qHNTfw4NEgWA8xbt26xdraGufOnePChQv3NI/wtUbJeH/16lXi8XjZzJ7L5VAUha2tPB/+xz/kuWfnODfQDOS4eUOUKARd3W7isSzDtyIVx5A4eGhnZmBbm2PXcp6iKNgdJn74/Wmg2BnoD1hZXkowNVns+nO5TLS2Obj0UrUXSlUpE6P9XW5sNitutwmDQcfYaKSOIPWfaeLGtTUymeLFeXoqxvRU8RilcFO7w8DTT84KvTNuj4lAwMroSPG4Y9v3N7XY2LvHRWYrj8Nu5KXnxL6tQkEcldHX5+fS89rbOlwKqwLPv9W2Sy5VLIsKrEczrFcErxpNMjpVJqfx3hw9FWD4mjYJPNYf5Nbl+sdsDgPZTcGMRJsJ0CZYEUEZcLfyZWJd4OfabZuV+o5IiXrCVI/djepbaRXrdpVRVasjLGo/R1WZW1J1dl4pXLR0l+xzMD09za1bt3C73fj9fgKBADZb9WzCH3WUyFUsFqsjV//iX/wLvve97/HMM8/Q2tr6gFfawOuBBsF6iNHZ2UlXVxdGo1EzquFBokT2stksAwMD6PX6MrlaXEjyyK9+h9GRCJ17nEyMr7O2ltkuqxVnBs5Mx1lcLBrJT54MMVox9qaEQkEtj8A5f76VldUkp043s7qcZGIiWvVc67bJ/OKFHVXqzu2NclJ7a6ud7l4v2Uxh1/LjseNBxu9Ulxa9PjPd3R7SmQKjw2FOnmrSVKVK2IxnyGYL/PD7i9jsBo4e9yEBY6MRNjeL+21usWMwyHVJ8gDLS0mWl5KcG2jh8tUVDpzyYzbomJmIsb62o271n2vm8kVtAmUwykzdjmo+BqCXLYC2v2hNEMBqMMpM3dEe07N3v5sJgQnfZBJ/jYUFMREtHQ6mb2kfy2QwA/W5CjangXhEOwpCrxf7rESeMoNeOwPL4tBpespeHsGqhmyoUbwUtZwrWvHP4mM121Z+/qSapcrb5KtEtAK9HXQNDJBKpQiHw6ytrTE+Po7FYimTLbfb/bpm6b3eUFWVkZERotEop06dKocyq6rKJz7xCb75zW/yzDPPNDotHyI0CNZDDKfTWSZVu6W5v96IxWIMDg4ClDNjSp2CV4bW+PVHvkN4LcXho34m7qyTSm0nSStq1czAffvddHV7mJyICv1HJpPMkaM7wZ+lENGWVjudnS5isTSRSAq73VjOxNKCy2Xi6pUVohuZYm5Vj4dstsDIrTCZbT/N2YEWLr+0VGe4X4+keTGyhE4nceZsC5lsnv7TTYyNrpc9XyV4vGaCQStDg8USWzKRY3DbP2UwyBw9GsDtNbOynGBsVLuDr7SWFy8WSdzQtu9LkqCr10PIbyOXyTN8Q5wUf+JkE4MXtH1bHXudjN3SPrbTrWNGY/YjFDsib9/UViFdbrNwLVubgjR2h4HVBW0y53DtoqJFtfcXbLGyGNcOtBLNQfSEzKSXtT97quD3jDtkJhGvJ4YSoBaUKlZUT8Kr79DppapMVJ3wmfWoInM1xK4cLrpNtOz7/ABYLBba29tpb28nn8+zvr7O2toaN27cQFEUfD4fgUDgR66UqKoqo6OjrK+v09/fj9m883n91Kc+xVe+8hWeeeYZ9u3b9wBX2cDrjQbBeohRKfm/URSspaUlbt68yf79+7l9+zb5fB5FUVBVlW9+fZz/+5VRnE4Te/c6Gby8gijsXa+X8AcsfP+xKaBImDo6nVUxDF6fmWDAWjalV2JxIcHiQoKubjc2mxGfz4LTaWS4gjCVcPpMM9evrZbLeevraV7aVn6sVj0nTwXw+S28dLGeXJVgtxvYt7/afK/Xy1XBqEajDlWFsVFtEpLLKSBLDF5aJpnMsW+/E5OpQCKhMje7M97l/FtaqxLrS1DVoiq3vp7GbNKBVebYkRBKXmVydINkoqiqeHxmJnYhb01NNuY14goA+g4GufyCNjGz71Iyy6YFBnJgXjC4uq3TwcTNqGA78RxE0XBqh8uElrIFkIxplxQ9ATNLy9rbpAXb2F1GEoJYBzWvQsVpumuXYE3ofCVpUmtyr3YnXDXEbVu50hmgoICzr6luC71eTzAYJBgMbmfUxVlbW2NmZoZbt27hcrkIBAIEAgGsVusbxv95ryiFHofD4Tpy9ZnPfIY///M/5+mnn6a7u/sBrrKBB4EGwWoAuHty+msNVVWZmJhgamqKY8eO4fP5uH37NqlUCqvVyuc+c4n/8p8H0ekkjp3wMTW5ztHjXjJpidGRag+Ty2Wird1RJjmwQ5igGMNw7ESQbFbh0ovicNATJ0OMbZcWJ7dLhiXCpNPJjI1GOHQ4sGtJUFFUJEniB9+briZMU7HyrMJQyIrNbuT6tWrFKJ9XysGoBw76kGUJp8uE0aQrr6cSZ881M3h5hXy+ePGbnNhRilpa7XTucWK1Gnjy8Rnhen3+IpEsecoi252PBoNM71EfLocJi17Hxae0z5vba+KWwA8FsLKoTV4AFmbEHro5AWFr6bSzMi1QqZziuZkilcrfbCEmSITXC0p6ABuCUqTNKVbK4ho+KxDnc+nk4kzDe0EOqZKPVZna62aZ13mwKv6t01HpS9OXUtxNMpmcAWuze9d1SJKEy+XC5XLR1dVFOp1mbW2NcDjMxMQEJpOprGx5PJ43TSmx1Ci0srJCf39/1QzBz3/+8/zRH/0RTz75JAcOHHiAq2zgQaFBsBoAHmyJsFAocOPGDaLRKOfOncNms5HL5fB4PDz//Ev82Z+s8cJzERxOAy0tVoa2Tcvh7fl3Pr+Fri4P6XSeeCxDPq9w66b4It/W7uDSS8skNrPbcQZBJFlibCRc9jANnG/lxYuL5W6+Era28gwNrmAwSJw81czmZpZzAy1Vo3dK8PrMBALWchdiJWEC6Ory0N7hYGMjvWv58VR/EzdrEt7LJcx4hrGRCGfOtuxK9NYjKUIhGxeeXyyHm+bzCsPDYdLbXW5NzTYMerlMriqRyxXXPnC+hR8+M09Lm509nS7yWwqToxvlfXR1exh6UbtDsKfPy7hA+WrtsLM8q02UOvc5WJjUfiwYsgkJliJQCwGWZrQJmz9kFRKsvKAM6PaZSIa11ShZoDFZHDoSEW2SJ4lUWaNc78G6y+3ac7BLvmv9OioYVy4nYargigb99iJ1Mln13gcTm83mcimxUCgQiUQIh8PcvHmzXEr0+/34/f6yUfyNhtKPwqWlJfr7+6uCmf/wD/+Qz3/+8zz++OMcOXLkAa6ygQeJBsF6iPFGKBGm02muXLmCJEkMDAxgMBjKZvbmpm7+1W8/yrWrEfwBI5KkMjZaf/GPhFNEwikOH/GTzhRobbUTarIxMhwmmawmjecGWrhU4YNKJnNlAmQwyBw7HiTUZOXK4EoduSrB6TTS3uHkxYvVKk73dqr64uImqgK5vCIs5wHY7AZeenGJZDJHa6ud9poSJohjGEqKnF4vcfZcC7mcwomTIYZvrZLJVD/Z7THRFLKVM7aiGxleerGo7pUGWtsdBpYWk8JB1qVzVxoHtLiYKDcRmMw6+k74CPmtzN3R9leVXq8Ibe1OIcEyWcSfS3kXwhARjAXyBoxsrgnG8djEX4mxsDbx8rdYmQ1rG+ZFo3B8zVY24tpqnmgbnU6qSl4H6lWn2sdrPsO7Kli1qHhuNq1CBc/R6Uq+R4WC6dV1Cup0urpSYjgcZnZ2luHhYVwuV1VX4hullDg5OcnCwgL9/f1V3ZJ/8id/wu///u/zgx/8gBMnTrzm6/j0pz/N1772NUZHR7FYLJw/f57Pfvaz9Pb2lp+TTqf5Z//sn/GVr3yFTCbDu971Lv7oj/6IUCj0mq/vYUaDYDUAPJgSYTweZ3BwEJ/Px+HDh1FVtWxmv3UzwiP/4Duk03ne8RPtrKxGuT0mmpgLZ842c2VohVxOYal04TfpOHYiiNmkZ3x8nZ4e364qj8mkQ1VVvv/YNJIEvX1evF4LC/ObzM4WiUNLqx29XtZUyEpdhYcO+8lmC7S02nE6TZoxDLVEr3J8jtdrprvXg9Np4pmnxDEMdruBvfvcVX4qo1Hi2PEAJpOe27fXsdkMyJLEqIDoZdIFcjmFa1eKuV4HDvpwe8zMz8arBloPnG8RzlrMpAssrySZm4+zHknT0mans8OFmlWZGo2SSuTpPeDl2mVtlU4ClubE720+ZUSrI1ECZse1CZ3bZ9IcWwPg9MlCgpXPap9so0nHqoAA2hxi4hhb1SZldpeRDbQJVkqQSl+kFbuzIp1FBxVKtFpQykSpoN6jglUVQlr9mCwVz18hW0AK3L8ZepWlxP3795NOp8tdiZOTk5hMpjLZepClxKmpKebm5urI1Ze+9CU++clP8thjj3H69OnXZS1PP/00H/7whzl9+jT5fJ7f/d3f5W//7b/N8PBweW3/9J/+Ux599FG++tWv4nK5+MhHPsLP//zP8/zzz78ua3xYIanq3SZQNfCjCkVRyOWKX+bDw8PodLqqXz2vJZaXl7lx4wb79+9n7969FAoF8vk8qqry3Uen+c2P/pBUKs+p/iBXr65RyKtYLHoOHPSV/U/xeBZJgr4DVkaGxd4eq1VPb5+PdDqP221mZjpWVl9KaGq2YbHoNctjAJ17XOzvcrMeSe1azjt9prkuS8vvt7C/y0MqnWd0eI1T/buX88wWHQcO+LkytILVqqfvQPE13x5bJxYrXrCDQQt2h0nTi1VCX58Xs0WPxaJnZiZe9qBVov9ME9evrmpmf3XucdHaasdi0fP4D8W+LbfbhMdr1jx3er3MgQNemoMOVmaTzN6JodYc6vipIDcGtTsWm1ttrAlmE4ZajUTmtcnIsdNBbl3SLhOfOBfi5kXtx9ra7Jom9z09TpZuaxOsYwNBRl6o35/RpMOQlepeL8DRtwaZeDZSd79OJ+GQZAq5+q/lTruMRU7jtu0QqK2sjNW4c4CNPHgqfjZnFTBvD3POKVA5aWcrK2Mz7RDNZFbGUaUWKui3t93KyPhcOyTX6Y4jS6CzbGE8eZTD/+Zn61/kfUahUCh3JYbDYfL5fFVX4utVSpyenmZ6eppTp07hcOyMCPpf/+t/8c/+2T/j0Ucf5W1ve9vrshYtrK2tEQwGefrpp3nb295GLBYjEAjw5S9/mfe9730AjI6OcuDAAS5cuMC5c+ce2Fp/1NFQsB5iVErtr5eCpaoqk5OTTE5OcvToUQKBALlcjkKhgCRJ/OF/vsLnPvsiAP2ni2NvSkil8uV4Ar1e5sTJIH6/latXtD0/UDSQ2x3GcnmshP1d7qJ/ZzmJXi8TiaRYXtImVwCBgIXnn5snky4QClnZu89NIpFjZDhcVqEG3tLKBY3uvHA4RTicwmiUOXGymWy2QP/pJkZHIiQS1QShNHewtN6S56v0mg8f9uP1W1lbTTIyXH+BLuH4iSBjo+ukUjsX43373ISabaytbjF+Z4OB861cvLAgVMjm5+KEQlYe/+EMgYCVffvd2yQxXCZkHq8Zr9csLC3m88Vw1u8/Xuzm9HjM9HR5MMk6lqcShJdTbMa1vUgAHXtcQoLV0eklMi9678Vm8E2BQmR3GoQdhC6fhSW0CdaWoBsw0GplY0LQDZjTXp+31Ux6Rlv1UgsqUp3/vfrNqxWo5AoVqrYkWPu2yzVCnCRQyxRlp9RoNBQwtb0+s/R0Ol2561BVVTY3N1lbW2Nubo7h4WGcTmf58deqlDgzM8PU1FQdufrqV7/Kxz/+cb75zW8+UHIFxZgbAK/XC8Dg4CC5XI53vvOd5ef09fXR0dHRIFivMRoEqwGg+OWVyWh/sd8vFAoFbt68ycbGBmfPnsVut5f9Vtmswqf+zQuMDK8TCtnw+Q1V5KoWPp+ZeDzLlaHVqnLe3Fy8PI+vtc1EYjNTZz6HYt7VxHiUk/1NrEdS9PR4iAWtjIzUl/MG3tLKxRd2iMjKylZ5ny6Xib4DPhwu466Dod1uEy2t9irfltEoc/RYAIvFwMT4BjabgVxeqRqFU4l8XkGSJYYGiwb9vfucWCwFYjGVhfmd11hbfixhcjLK5GQUSYK3/Vg7mWyBQ4cDVSSxBItVT0+Pt+zVWlvbYm2teIxSY4DRpCO6kd6V6J0521yl1m1spHnp0k5359vf0U4urdDn8jF3Z5NkbIdsGU0yEyPiOIhNwcBogKVZ7dKhyaJjfkL7sdY9DqauRTUf0+1i9grPa5Myp9ckJFiZTe0fMy6/aXeCVUN6DDY95HYInlxbyqv49936D3U1V4PKcNHK3SoVMwuNhjz2rtd/np4kSTidTpxOZ1UpMRwOMzk5idFoLCtbXq/3vpQS5+bmmJyc5OTJkzidzvL93/jGN/gn/+Sf8LWvfY2f+ImfeNXHeTVQFIXf/M3f5C1veQuHDx8GitUCo9GI2+2uem4oFGJ5WTyDtIFXjwbBagB47U3umUyGoaEhgLKZveS3Wo9k+I0PfJfLl5YJhayYzBKJRJr+00HmZhN1BKm7x0N0I1NWTWqzofbscdHV42ZxIcnCvLibsFLBKY2hKaaqe0mn89wei3DkaFBTlSpBVVUSiSwvXlzEbNZz4mQIvUHmztg60e1RL61tdmRJqhrTA5DNKuVohkOH/UiyhMNuRCdLVf6nEk6faebqlaLPDGCqIrCzZJK3W4088cS0MB/MZJI5fCTIM0/Ple9zOo309HpRVBgdDmO26PH5LMI5iclkjkhki61knvX1NIeP+LHbjUxPx1he2lF5Tp1uKjcQaKGp2cblwRUS20GhsizR1ech5LeSSyh47CaGntNWqNr3Ohgf1iZf/iYr64L09OYOKwtj2oTI7hCXmEQqlTtgJrmqTfRMJu24BYB1gVJmtmp/Jev0Eqqi1nURRreyBCrS2msfr5o1WJt7VUPG9AYd5O7+HVAiWCoqekMez+H6DKzXG2azmba2Ntra2sqlxHA4zPDwcLmUWPJuvZJS4vz8POPj45w4cQKXa8dz9uijj/LBD36Qr3zlK7zrXe+6ny/pFeHDH/4wN2/e5LnnnnvQS2mABsF6qFFbInytYhri8ThDQ0N4PJ7yr6oSubo9FuXX/sGjLMxv0tPrYWUlwcpK8WI2M52uHpI8v4k/YGH4VoS0IHgSimNiHv/BDKpavIjv2eMivplldDiMooBOB/u7LZo+qGKq+iJOp5G+g34URaX/dJNmR2LL9jiakuE9nc6XS3s6ncShw34CQSsL85uaI2tK6D/dxI3rO3MHATo6nbS1OsrDnUXlxxJWVpK0tDr44Q+n8XjMdPd4yGULjIxESG/HOzidRtranXWkJx7PlsNW9+x1EQxZkSjGX5RysCpx8JCP+bnNcsr8zYph0KXSq9Eo8dwzC8JgVav1V46XAACn3UlEQVRVj8NhrCJkiqJy+/b6tjlfj9dlwX/ASsBrJZcssDC+SSpRfA+amu0sTWob4/fsc3JVQLCMJrGOk0uLycWKwOAeaLYwIyBYu6W7p5YFRnZRunuLGRZTdSNr6kuCO/9WqTa1361rsHZbkWgnbT+QL0hkckbMfof2Ex8QKkuJfX19JBIJ1tbWmJ+fZ2RkBKfTWSZbdrv9rqXEhYUFbt++zYkTJ6pUoO9973s88sgj/OVf/iU/8zM/8xq/qrvjIx/5CN/+9rd55plnaGtrK9/f1NRENpslGo1WrX9lZYWmpgdPjn+U0SBYDQCvnYK1urrKtWvX2LdvH/v27asysz/z1Dz/7298j2Qyx8mTQW7cXCNX08VVOSR54C2tLC0mOHkyxOpa0UdU/RokTvY3VRGn0tw9KPp/Dh7yYzLLPPuMuJzX0mLHYNRxZXBHPdnpSNRx584GgYCVtdUtFhe1L+SFgorJrOfCCwtk0gW6uj0EglaWFhNltQwQ+qBmZ+LMzsTR6STe+rfayOcVjhwNMHxrjdq3qdRNWBowvbGRLpf2LBY9J0+FMJl1RDcyVaOEatHd4yESSZXXJ8sSfQd8eDxm5ueKXYUnT4W4dStclclViYnxKMGgjaefnN8mt24SiSyjI2Hy+eKLNBpluro9dcGqlTh2NMSLLyyySIJRisqfTiexr9dDS8hGtlDA5TdpRidENErCJRTSgo5ECeYFHYktnXYiM4Ig0V06CEVBor5mC0sCgpXZ1P7hYPcZUJZSpA0q9or7a0lQ1WxB6V6S2kGq+BCqNaSj8qasL94oqNIrysB6PSFJEg6HA4fDwb59+8hkMuWuxKmpKYxGY1VXok5XrTouLS0xNjbG8ePH8Xg85fufeOIJfvVXf5U/+7M/4xd+4Rde75dVBVVV+ehHP8rXv/51nnrqKfbu3Vv1+KlTpzAYDDz++OPltY6NjTE7O8vAwMCDWPJDgwbBesghSRKqqt53k7uqqkxNTTExMcGRI0cIBoNVZvY//W/X+f1PXaCr20Nzi4VbN1fryFUJBoPEiZNNZQWnRACamm3s3esmFs+wMB+nvd1Zld5eC4tFz/z8JjPTMWw2A0ePBpFkGB3eMZu3tZmIx9PE49UXukymwLXt7sFT/U2k03l6+3yaHYlQT5zG72yUCWFbm4OOTidWa7E7T2Qyt1r1dPd4ea7C22W16ug74ANJZnQ4jN1uwO4wceO6NllJpfJEoxk2N7NsrKeLSfIOA9NT1eW8o8eDjN9er5rZqCgqoyM7Zc0ff0cHmUyBPZ1Oxsa0FblinEPxfaokt6UypCQVSbPWeKISTp1s4qUL9ZEQhYLKndvr+Pxmnn6hWOJs63TQ1uzAJOvYXM1AVmFuQlvZ8jdZmb2tTaKa2s1EZsQzCEUEK5fWVqnMVj1hQRnQskvWVnypmvzZ/EasB8wsG/MEgUJeqcqj0tfkLlTlXNXs+24ES1XUsiKWzatUV9J2ti6Z4VUV8sZKuvfGh8lkorW1ldbWVgqFAhsbG6ytrTEyMkIul8Pr9Za9WxsbG4yMjHDs2LGyYRzg2Wef5Zd/+Zf5oz/6I/7e3/t7D/DVFPHhD3+YL3/5y3zzm9/E4XCUfVUulwuLxYLL5eLXf/3X+fjHP47X68XpdPLRj36UgYGBhsH9NUaDYDUA3N8SoaIo3Lx5k0gkwpkzZ3A4HOTz+e25gvC7v/0Mf/W/hzGZZEwmeOqJ4gV5z14Xzc12Vld3Ai+L5nBHWZGpROkC3tZup7nZgdVq4PiJIMO3wnWxA30HvKyubJXJUGXAqNFYDBj1+ywMj4SJx8Vmfy3Fad9+N6EmG6vLSaamondNVY+sp/AHLLzw/EI5hT6VzjNya43cdnu+32/B7THX+aC2tgoMDRbv6+nx4PYU555Fo2nWI/XKzJGjAaamYmWfU1WSfHcxGNWgl3jhhcXyiB3N1/2WVp58YrZ8OxCwsq/LTSpVXLeqFgdAi7Ky4vEst8fWaW1zMDG+wdFjAaxWQ10Cfk+Pl9sajQYlhJpsXB3aOSfzc5vlpgaAA4esWPsMNPmdSDmIL2VYm0uCKtGxz8mNZW0i2tLuIjKj/VgmJTbTr81qk6imThurw9plRQS/YyxOHclwFp1BInjUQUSf5bkbK2QvKpw5XQyErLVq63VSVe2vytSucJfB0NVQ8zuZWbXlxEoFq2SGVwHZ5d59p29g6HS6clp80UtZLCUuLCwwPDwMQHNzM1D8TpNlmQsXLvCLv/iLfOELX+D973//g1x+GX/8x38MwNvf/vaq+//iL/6CRx55BIA/+IM/QJZlfuEXfqEqaLSB1xaNHKyHHCUvVCwWY3BwkHe84x2ven9DQ0MoisLJkycxGo07x4hm+Ue/8T0ubBMLp1PHlMBH09Jqp6e3aDZ/USPJvISDh3wsLiaIbuyQIpvdwIEDPlQVRobDHDzk58aNNWFZC3aIkyRJ9PZ5cbtNVdlRxU5FK6Mj4vKTxarn2PFiR1VtInsJPr8Fr9es6ckqrdtolFle2mJyMio81qHDfmZn4mxWGMRL656djbMwn6gzxWuhNPi5PHonlmZ0JFI2ycty0Vz/4i7KYCBg4eBhP8lETjN6ovQch8Ok+Zq6ezz4/VZyuQIToxtlb1ctdDqJnl6vsGvR5daRTlHlZYPied3T6aKzxUkmXiAdzROZS5NJ7PygOHDYx8QNgWneZ2QzUv/Z8YYsJJa1yfjRgSDjL2h3g3b1uVkaqW5isHoMtB53Ek9nGBpdI7ZZfQ6O9fjovq1gcm3hr6hKZnQSpgqfm6LuqFipAtj0O49FsxJu487tREbGYd55XQqUc68SeQm3aef8pHMSHkfxtRqcOmy6Dbby4Ht7L4f/9Xs0X+ebFaurq1y/fp22tjYymQx/+qd/yre+9S2OHDnCxYsX+fSnP83HPvaxB73MBt4EaChYDzkqS4SvVsHa3NxkaGgIl8tVnr9VIldTU5t89vcvsjC/yb79LmLRFFOT2mUXAJ/PwtDlZeLxbDGos9tDKpljeHjHy6MV6gmQTOTKJai3/K1Wkokcx48HGRtbryJiULxo95/e8W2pqlp1Ad+3301zix29TuLpp+YQoaQ4XaxQcIodiR7S6QIjw2GaWxxkM3mh4T2ZyLGVynN7LE46nefwER/5fIrlpRzR6A5p6T/dxPVr1eGgilK97nf8RAepdIHOPU7G70TrjiVJcPZcSzkFvnIYdskkn88VkHXyruTK4zXj8Vp4+sniuTEYZI4cDWC1GZia2GB1NUV7u4N8QRUSxju3NzAYZGZnN3E6jPQd9pPYzDI2HKkyyfefbeZFgUIG0NXtY1Aj2iOZyJFK5/neD6aq7m9qtREM2PC5zBgLMvuPe0isZ1lfSZHLFM+tv9nK5pI2iXL5ZRKCSqdoBqEExJbSBLpsmAN6UroCc+EE1yZWOJGXuHlJW0UrDpM2IaNSaW2vPIqq3qVrUHupO/vaxRBfmepeOogkqVj2+O+y1zcX1tbWuHHjBkePHiUYLP5Y+tznPse+ffv4d//u32G32/nd3/1dnnjiCX76p3+a9773vQQCgQe86gbeqGgQrAaAosldURRUVX1FAX2lX3179uxh//795ZR4VVV5/rlF/vFvfI9YLMOx437C4QTNrWY8Xqvmxf/cQAuXLy2XS1aloE4oenl6+7y43Gaee3ZOM4Ecdnxbzz+7U6ordfY5nUUlZSuZZc9e964EIrGZYXmpaN5ua3PQ3uEkGi2qPCV1KhQykM8X6kz3xY7E4r5PnAxhMMgoiko8nqnrSIT6VPWbN4qESZal8ggbo0HmmafnhIpeiTg98fhOOa/USbm5mWVkOIzBIHPocICLGj4nKJrkb4+t09RkY2YmzslTobokeSg2A+h0UlVuVy6nlP1gklQkuDpZZmZGHOJ6/ESQ0ZF10uk8ic1suYxb9m2pYLXoee4Zcdn14CEvQ4JRPAABv5WZieo1lErMZwdaeObCDnmWgGCTFb/HSmiPFe9eM3pZRlYl1DwoOYXMVg6jU8LVIqMqxXKTTqfDYNSjM0hggs7TbmQDKDrIqgrxVIa8VODFG6vkpxWYrl6jiJS5vCa2IjmQTPWm9gomVKD6C71ubGHdZ6YmpFRP2bi1W4lQKaigL84jtB9s1lzzmxGRSIQbN25w+PDhMrkCGB8f5w/+4A/49//+3/PP//k/59atW3zrW9/iS1/6EqFQiJ/92dc+xb6BNycaJcKHHKWgz1wux+OPP8473/lO9PqXz7tVVWV6eprx8XEOHz5MKBQqdwpKksRffukW//oTz5HPK5w+E+Ly5ZWq0SFlo3oszdhohNNnW6pUoFqYTDKHjwYZvLRcMTpHYmx0vVxacrlMtLU7NOcFltDcYqe11Y7RqGNhfpOZmXrz8/79bjY3s6yu1pcFS94pg0Hm5s21OmWsErVKm9Eoc+CgH7O52JG4HknfNVW9RJwuXlgse9XWajopTaYicRoaFCfbt7U72LffzWY8y8hImHSqvvTV1GzDaNQxW3NO9HqZvgNe7HYjqVSOhflEmfhq4cjRAJMTUZLJXPnY7e1OYtF0OdD19JniDMld/V/nW7l8aYm+Az7sNiOzNQZ9n9+CTiexKugebG13EFnZIicg4329Xu4ITPvHjoe4eUVbVerp8TJ5O1p3v9EkIxckCvn6N/PkmRA3X9Te38GDfiaG6/fXe8jLxs0Eb5NsONxJnPodtpNnh1RlFTBWeK42cxKuijE66xkZb0VMRTIrYa+4nUfFuN1Et5GVCFh2fgTkFRWHdVtFNSq4bQkUU4GTX/0YBsvrM6LmtcT6+jpXr17lwIEDZd8VwMjICD/5kz/Jxz72MT7xiU88wBU28GZEQ8F6yFFSq0rtyfl8/mUTLEVRGB4eZm1trcrMXigUUFX45L96ji/9+Q30eokTJ/1ceqn+wl9SEWw2Paf6m1EVlaPHg1WG7xJ8fgt+v4XB7fJf5eicUmnK5TaysZ7elVz19HiJrKeqOtlKuVNr4RR3bq9z7HiQ8fENkhp+IoBIOMX+/e5ywOjpM80UFJWRW2ukKkjLocP2cnxCCdmsUjav6/USP/6ODtLpPM0tds15gSXiVFKcpqdiVZ2Ue/a42ErlKeQLu5KrUJMNnU7mme1SZykY1WAoqlPRaKZMvmaX6glnPq9w80aYQ4f9zMzEaQrZ6O7xsrycqJtDqFXGrDSke31m+vubWVvbQlc9n7gKA+dby+Xbyk7J1nYLHreeQt5AIacKR/UA+DxmlgXDpPfucwnJldNpZOymtt/L57cwpaG+AnTutTM9qn08vU47UVwClma1t7E7jZTObp2CVVExvNsonPp7qndW2ZBY98zKEuF2t7FkMv5IkKuNjQ2uXr1KX19fFbm6c+cOP/3TP82HPvShBrlq4BWhQbAaAECWZWRZftlRDdlslitXrlAoFBgYGKgysycSOT70we8zNRXjrW9rI5NOc+klMeEJNdmw2QxVnYIOh5HjJ3wUCgrDw2Gam+yk0/mqxPZK5HIKhUKRAMRjWQ4c9OFym5idjlfFKJw8FdIMKi3lTgH82NuLY2T27HExsh1OWovK4M9cLlsmUSazrkhajDJGg8xzz4rLWqWhzpXdec3NJjo6PYTDaSbGo7jdJppb7ELitLyURJIkjAaZWDzDmbPN5HIKI8PhcsAoFL1km5tZZqZ3iFBtMOqP/0QHuZzC+JY4FPVUfxM3bxRDUcc3s4yPF59bSpKPxzI4nUZevLi0a9dab6+P73+v6ImyWvWcPBWoKkPqdBInTzUJuzEX5lPEogba2o1sxNP0DzSTzRQYG45UNTOcG2jh0gVxCdjrtTA7qR3d0HvAx9BF7fO+r8vNlbD2Yz6vnWm0yVJ4uT6hH6Cpzcb6vLYKqpOkcjOgrpZg3UMsw66kifqg0erHdu4x6LfPr+2NnYH1chCNRrly5Qq9vb20tLSU75+cnOQ973kP73//+/m3//bfPsAVNvBmRoNgNVDGyzW6JxIJBgcHcTqdHDlyBFmWy+Rqfi7Jr/39b3PnzgbtHQ7ujK2xspIh1GRl3z5PnX+pp9dLJJJiciJadYzNzR3Scqq/CUkqlsmSyZxml9npM01cq/AvVRq+d9LFZZ59eh5ll0jrgfOtVWb2kuE7m1MYubWGoqgcP9EkTFXPpAuMjUbo7vEyeGmZQ4f9OJxGpiaq4wjsdhmfz1Q3hHppKcPSUlFZO3osgMdrZm11q5wfVYv9XW7isSxL2ySyNmBUp5Mp5AvcvhMtRzVo4fiJEC88t1DuwCtFOKysJMvvzbmBFl56cUnz/C0sJFhYSDBwvpXRkQinz2gTPVmG/jPV8wlrB1ofPxHEH7BUJcTXwuU2EQrZyjldpTmJZrOeo6eCmIw6lJzC1ctiRa+3z7vr41sJ8d+ColH+KyEe1SZKBr3M8px2STUQEhOsVDxX9mdVxmDWpDDUJ7XXLbHa9F7J1QqAoZJg1XqwKoYcGo1FVVdyWjXX+2ZBLBbjypUr9PT00NraWr5/dnaWd7/73bzvfe/jM5/5zGsyNLqBhwMNgtVAGS8nzX1tbY1r167R0dFBd3f39qDmIrm6/NIKv/GB7xbn0x32MTkVZStZ3N/K8hYry8WLoN9voavbg9GkY/DSkqbhu4TawcUGw/aAZKuB8TsbRMKpu46RmZqMEghYefrJOdrbHbS1O1lfT1WpYWazjkOHA3WKSWUqeqjJRm+fl62tHHa7QRhH4HSZyiXAylJld48Hf8BKMpFlbW2LmRlBTtL2cxcWEuW0c6/XTHePl0wmX875OnI0wORkVLOMWSqf9p9uYnR0nX37Pdjt9blTpXNcS5xqg1EPHvYzPxdHZNksxjns5H9pEb2Z6SitbbuHwVqterLZAj/8/gywTY6D1u0yZLx8jm12o+ZQ7JIq193jYWU5Scs+B0G/lchaisk7G7A9R89olItmbQH6DvoYFZQHzRYd44KyosmsY3pc29Dfud/J7Ki2WpYvaE8EkIClqQQlKlOlMsnVGVh3U7BqaYLBKsO2962ggEE8OhHdtoKlIG1HOajI3jdXyGglYrEYQ0ND7N+/v2qszMLCAj/1Uz/FT//0T/MHf/AHDXLVwKtCg2A95KidRygiWKqqMjs7y+3btzl06BBNTU0VfiuVv/nGBP/5Dy6zvp6m/3SIK0MrdSNdSgiHU3T3enn26TmcThNnzgbI5QoM3wqT2W6Pl2U4c7Zo/K5ELrczINls0RXLeZkCTc22KuNzCXa7gX37PWX/0tzcZnmQcjBoZe9+N5lMjkxa2XUwcXNL0RBf8i8ZjTJHjwexVBjV9+4teqFEfqA7tzfQ6WSWlxPbr7uJhYUNFmqUi64eO/Nz8Sov1/p6mhcvFl+DzW7g7T/eSTSaFvSdFTFwvmiKV9XqgNHunqI6tbiYoKXZzgu7hKLKMrS02fn+Y8Vyntdrpqt7R9HLZBRMJpmDhwLl9VWiRPQcDgOde9xkswXOnW+pS5KHoq/J5TJVDcWeGI+Wz2cgaOLgoSDZTEHzWCX09HpZWU4Sj2eJx7PlWIxAwMq+fW6UnILNoufF58REz2QUfzUeORbkiqB02HfIx/CgtvLm9VmYRUCwUtrvZEunneh0Gjs6QK1TsCpv303A0htlKmlYIp3Ds22Yr/dv1ZQPt6UyRZKRJCgoEvomt+aa3+goxcns27ePjo6O8v1LS0u8+93v5id+4if4wz/8wwa5auBVo0GwGihDVCJUFIWRkRFWVlY4ffo0TqezTK5A4tP//kX++A+vIMswcD5ENLpJW7uNmel6wlNMTQ+VFadYLFNWO2w2A4ePFMfXSFBHrirh9phobrZXlfO6uj0Eg1bm5zeZnYkTClmx2Yxcv6bdvr+6uoXFoieXV9jaynHmbHMVcSihu8fD+nq6XIaDolH9+rZKJctFo3our9RFNVSico5fdCNT9nyFQlb27HOTTOSwWCSGBteEQ5IBjh4Nlv1LpRR6s0VfVvSgNLJGm4Tcub3B5ESUU/1NzM3FGTjfysZGitGRakXIbNZx4KC/SnFaX99R9KxWPecGmrDZjFx6SUx4/P6iqldJ8mCndLuynCSbLab815aKK+F0FMuGkXAKl9tEb6+XfE5hZDRCanvEz8FDPmZm4pqq3traFmtrWwycb+GFS4v0HvPhshlZXkiyMLPjjTp2IsjNIfGcxPguHaN6WdvEDpASzBnU62WWZ7QVLLOlSLJlJJSaCJVab+DdhjkbDFKx7XAbtWRtN5Q8WAWleHxVlnB1v/kGBW9ubjI4OMiePXvo7Ows37+yssJ73vMe3vKWt/Anf/InyLu8jw008HLRiGl4yFGKVAC4dOkSzc3NVZJ5Npvl6tWr5HI5Tp48iclkKpcEU6kCH/0nP+T7j01htxtoa7cyOrJTHmluttG510U8mmFkJILbY6apySZM4oYi2bDZjSzMb3LgoB+jUcfYaKQqf6mjw4miqMzPaxuGAc6ea8Zk0rO4mBCSnkOH/czPbVbtG4pEr++Ar+h7AoZvhkmlxGXM2sT0EtFbXNxkeqpIogbOt/DiRW3/UgkD51sZHg6XicOtW+GqVHJJgqPHPFy7qv16SnlZLa12hm+FWZjXNlpbrHp6erx1Y3gCASv7u9xsbeVYWNgkELBVzSKsRWU6u8Eg03fAh9VmYLqiDNnWbkdR0OyOLGH/fjd6vYzHZyYey1QlyZdw8KCPubnNcnJ9JUxmHQcO+PD6zAzfimgqmSWcPdeiqX61tNrp7HChZgtsLGdYEHQd9hzwMjkS1XzMbNFhQEda47NisemRs2hGRXQf8DA7ov1ZPt7v486lGM3oOYKJjsAOEUsWwFbBktZz4K1IeV/PSvgrYhiyJiPGzM7521IUbNuu+UQenKadz2Y4I9FkLb4ORQWbpbjdVk5HS3CDnF7H0f/xD7EHHZrrfiMikUhw+fJlOjo62LdvX/n+cDjMu9/9bo4ePcr//J//s27gcwMNvFI0FKyHHLUlwkoFK5FIMDQ0hN1u5+TJk1Vm9uXlFI/8g0cZvhWmpcUOUqGKXAEsLSVZ2r7YFSMUTMSixQ4xLYWmp8fL+vqO4f3qlR3j85Gjxdl1hbzCnTsbdaSoEidOBrlxfa08uLhM9CrG14hS4GFnTuG5gRauXlmlt8+L2azj9u0NNtarlQYt/1elf6mj00Ffn4/p6biQXOn11R1z9f4lianJKE0tVq5d1e6ihKKiJEnwg+9NA7Bvn5tQs43VlZ3Zjh6vmUDAWkeuYEfhCYWsBPxW7A4Dp/qbGBkOVw2BBorp7HmlnM5eGzDa3eOhrd1JeDXJjV3M6gcP+ZibrSZOHo+Zzr024rEkC/NZDhz0l4NItZBJFzAYdDzzVLGB4eAhH06XibntkUElVEY+1GJxIcHaapKeXh9TazF6j/lw202sr6SKAaWqhATodinKHjzs54Ygib2718PooDZZdXstzKJNsHJbxePJlO1jZdwtlqF2pQWduGtQqUl9p6JrUFHqVbOC0fCmIlfJZJLBwUHa29uryNX6+jo/+7M/S19fH3/5l3/ZIFcN3Fc0CFYDZVSa3MPhMFevXqW9vZ2enp4qM/u1q2E++a+exeUycao/yJ3b68TjYoXn6LEAk5M7A4ddbhM9PV5yeYXhm2tks4owPgGK+Us3rq9x5mwLN26ssXefu1gKqolgAG2lqJLo+fwWTvU3sbKcFBq2Jalo/C6V2EpkpJQE73AYmZ2N0dbm3NVcbzLJBAI2vr9NeHw+I8GQAUkyMTa6QaGgYrPp2b/foznMuuRfcrtNtLY5kJE4O9DCxJ2NuoBPj8e4XYbbITOTk9EyASrOdvSQyShc3MVztWevk9RWntGKBgCTScfxE0GMRh3j4xv4fVbW1rbY2NAua6kqGI06Lr20RGIzS3uHk7Y2R10Z8vjJEKPD9e/5xka6vO9zAy3kcgWOHA3UJcmXcG6gqEqV3s5KD9eevS5amu2YLXqeeHxG+LpluRgqWspGu1FRzvQFLOzf58bntnL7iljRS8a1M9MAzLt4ujJb2mZFnSyxNFkkXjISak2sQp2p/S4mrGy2QGWwQuWKavdlNMqUplJXEjtpe6d5s1lzzW9EbG1tMTg4SEtLSxW5isVi/NzP/RydnZ381V/91T0FLDfQwMtBo0T4kKOU4g5w69Yt9Ho9FouFsbExDh48SGtrK7lcbsfM/s0J/vlvPkE6XeBkf5Ab19YIBE10dBaNxbWBk7VdgLWw2Q2cf0trMRz0VrjspanF+fOtmmbsko9ncWGT5ma7cPwL7IzPKZEZh8NI34GdrK10qoDZrOPgIf+ugZ1F47ybVCqP329lYX6T2dlq83Ipv0o8mNjE0WMBdLLMhRfmqzxflWhpsaM3yFWp6sXB0z48XjNzMzEkCVKpHOGwWNXr6nazsZEhEk6VOxLTmTwj2x2JAAcO+lhcSOyqDh47HqSgKNjtRmYrhmFX4uSpELduhuuGLkPRj7W/y4PVpufC8wtVEQ61qCVOOp1E3wEfDqexbJIvDaveDSXlKhC0sn+/m62amZayDKf6m+sCYSvR2ekkHE6RTObo6HDS1uJAysP8xCaxSIYjxwOMXhV0HVp1WGQ9yc16AmYy6bDoDaQ0Omm7DnhYGi4SrE4MdMl69vp2lL5oHtwVnCCcBX9F7mc0J+M1VjRKFMBbIdCoKMjbCvZGTsJn3vkMpg167Erxc5DX6XAYioQ+lZVoDsWItjfx//z5r4hO1xsGqVSKy5cvEwqF6O7uLiv2m5ub/NzP/Rxer5evf/3rmEymB7zSBn4U0SBYDzlUVSWbLX5pj46OEg6HyWaznDhxApfLVTazS5LEf/rcZb7wny4B0H8myOWX6stMpRiEcDiJ328TlmRgpzRWIjxmc3H0jV4vMzYaIR7PluMTduvws1r1dPd6ia6naWl11I2QgWIqd3uHU5jwbrEUU83NZj2XXlpkU+NiCDsesVozduceJ60tDlbXkqRSBWRZYm5Wu2MMihfsTLbA8lISq1XPgYN+ZFlidCRcPnZXt5voRmbXcTQHDvpQ1WJZbXU1qdnB2HvAzfxssjyyphIlv5nLaeTqtVXWI9qqFNR7zaC+DHl2oIXLuxBq2OlutNmN9PV5ARgdiVTFXtwtegPg7e/oIJMpsLKc1DTHSxKcOdusOWvS7igeW1WL0R+7EXOP14zdbhS+n3v3uti/10NmM094PkV4oToGo/9cE9cvaDdaHD0VZGxQu+x75nwzt54vKml7MbJPJ7PXu3OONnLgqfBcrWUhUEGwltUCLRVm7UhexVfuGlSpDJVfz0r4LTvva86kx5IvEqxNVSJoKf47oyiEfAniJ7r4if/wxp7BVyJXgUCA3t7eMrlKJpP8nb/zdzCbzXz729/G/CZS4xp4c6GhiTYAFGcSrqyskMvlOH/+PGazuTynMJNR+OTvPsdffXkYs0VHV5dTk1xBMQZhYyPN/i4PU1NRBs63ENs2uVdS+RLhqSyNVSaLGwwyZwdasNsMXLmyy/iXkBW7w8i1K8X1lGYKNjfb2LPXRSyWIRbLoNfJu47PCQatTE/HWFxIbGdtBbFY9IyP73TmlWYTal3MZ6bjzEzH6en1YrVK+P0WbDYdY6MbdaWbg4d8LMzvKEVbW/kygSwd2+czc+fO+q7kqrIrsYTmFjt79jiJbfvNDh/xMDIcLas1tUgmc+j1Mk8/PYdOJ3HsePF136noSITqyIdKVJYhf+zH28lmCvT2ectet1pUdjcmNrPlkpzeILG/y4rH68BqMfDM0/PC1y3L0H+6macqEvBbWu10bCfJj45E0Okkjh4LCQd5Jzaz3LyxRu8BHzeur5bf78mJDdbWdl6302nE57Ps2h3a1Gznh09Ml2/7ghb2dLiwmw1kNgukBaosiEfnACSjO2RK5mXEMJhkKgd95vMqVBCuiqxQ8uruEQ+Vq8pWfHb0sgKouPZ4hOt+IyCdTjM4OIjf768iV6lUir/7d/8uBoOBv/mbv2mQqwZeUzQUrIccqqqysbHB0NAQAFarlRMnTpTJVTic5h++/7vcuL5K/+kmIMvoaJRYVLu009xix2zW1ZUKS+GiyWSOWCyNqu6u8OzZ6ySTUVhaTCDLxdKQy2VicmKj3KHW1e0mFsuypjGMuYTePi/ZTIFgyEYqlWP4VriObBw87GdBo5sQip15vX1empvtTE9HmZzQDpGEorl+dGS9quPQ5TbQ1+cnlSowMrzGseMhblxf0yyflXDmbDNDgysoikpvn1dz5M/ZgRYuCVLVS3jb29vJpAtV4aR1xzrXxEsX69XB0ut2e8yYTLoqMqOFcwPVmWVer5muHg/ZTIGR4TC5nMLpM9odfCUUZ1Y2MXh5mZ5eLx6vmfnZeDm3DIreoMNHdh9o3dRk48AhH9GNTF2SfAk2m549e911pLto0Pfi81tYjyRRFKmco6WFg4f93Blbr1L1KnHqZBNXB1cINdlobXFgMxuQ8ipbGzk2IxmklKxZHrQ59Oi2dgZGd2OkXS+zz1OhYCkSngrWNJ3Nsce4I2kt5PK0G3doVCyv4tpWsNKKiqWCYYWzEsEKBSuv02GmqGyvZaHDWfy3rM9gc2Vp+lc/w563dQnPy4NEJpPh8uXLeDweDhw4UCZX6XSaX/qlXyKVSvHYY49ht795g1IbeHOgQbAecqTTaZ544glaW1uxWq2srKxw5MgRVFXdNr2rPPfsPN/77gRPPD7J7MzWjgfIY2J6Ol7Oh+o74GV1dWvXMtPBw3424xmam+1kswXNC/+RowGmp2KaLfmlC2Bbh4PZqRjjuwz51TLOO51Gevt8FPJF39WRo0FhN2EJZ841M3R5hXxeKaax+y0sLiTKahnc3WsG8Na3tZFOF/OeRoa1/Wa7eYpKfjOzWebJx+c0n1NCbQ6Wzb4dPQHlrsBDh13cvCEmjDqdxKn+Ygl37z4XTc121laTjFcMOdbrJY6fDHH5JXEJ1+02ceJkiEQiVy791sJs1tHb59Psbtyzx0Vzi53oRgqdXt51hI7DYaC9w1k2ulssxbJz5ZxDt9tEMGTTTIIvwee34HKayOYKtLc7icXSdapcZ6eTaDQj9KwZjTIhv00YUXH2XAu3hyMEglacDhNmox6DTkZCwmM3UYgpSFLRVu6eyOBK5uk07xCs2VyeDsNOEWKmUKCzogtuMZ+nrSKefbOg4tiOZUgWVOxV/q0agqWCeXvm4GoWOrcJltmyhWJXGfjq/4vR/sZTfzKZTHmM16FDh8rkKpvN8iu/8itEIhF+8IMf4HQ6H/BKG3gY0CBYDbC8vIzH42F+fp7x8XF6enrw+XzlrppUKsXVq1fR6Qykkn4e++403/n2BCsrxc68rm4Pe/Y6mZyI7RoUeeZs0cNTSWbsDiN9B7woBZXh4TDHjocYvLRMPi8mPJVkZt9+N6GQleUag/3A+aKistun+61/q41UKockS4zcCmuO7Nmttb9zj4uWFhsWq54nfihWeIpdidX7MZl1HDzoL/vNEoksp8+28OIuXqBKwtPW7qBdY+SPwSBx/ETTroZth8PAqf5mUqk8d26vs75eT4hNJpkDB/1cvVJPeEplyM3NLDqdrEmKSrDbDXTucZWVolJelsWi4/ZYmGg0j9NppLXNsWs+WokUxaJp9uzbNqrfClcRWq/PjNcrLueVzp/NbmBkWJyXFQpZMZr0dQpraS5lPqcQi2eIx7LlGYhaOD/QyouCsFdZkmhvdzA/qx3PcOpUUfkq4W2Km70GPQdcO693Jpens4JgrRogWGGzW8rlaa1QsLYKKtZtghUvqLgqCNZaViIkIFjLWdjrzKKq4HLHWZUN/MwPPip83Q8K2WyWwcFB7HY7hw8fLpOrXC7H+9//fubn5/nhD3+Ix/PGLm828KODBsFqgHQ6TS6XI5PJMDU1RTgcRlVVAoEAdrudqakpQqEQvb295YRjVVW59NISj35rnJnpOI99dxIotsU3N9u3Z8ftEB5RF2AJkgTn39pGaiuHTiczMhyum/UnScVf/SJDcnu7g/YOJ2azjiceFxMenU6i/3RzVbnKZNLRd8CHyazj9tg6ic0sJ07uTlSMxqJf6vKlZZqbbQRDRjY2UszNpsvEzmSSOXwkuKtJ324v5k1lMgUmxqs9QCWIwkGBne64rTyyBFd3ITwOh4GOzh3Cs1N+NTK13Zlnt+vw+gzMCtLFYYfwhNe2yqXAWjXS4zXv6l+SpOKQabfHxMSdaF0nZgnBoAWr1cj0dLXaVlYjCwrhcApVZdeyc3OLHZ0slQNqu7o9BIJWVpeTTGz/MGhrt1PIq+VYDy10djopFFQCQSsGo8z49qikSpw+3czQLqre6TPixz1eM6nNXFXZ8ccVD+0GmYOunedN5/LsqSBY6xYZb2pnm5V8gWbDjpsqo6iYtsOvonm1xiBfTbAKehXTtp+rRLByBYmAP8ai1cnPffM3hK/tQSCXy3H58mVsNhuHDx8uf0/l83l+/dd/ndu3b/PEE0/g8/ke8EobeJjQIFgPOeLxOOvr67jdbmRZRpZlJEkiGo0yNTVFJBJBlmVCoRDBYBCfz6cZxnf1ygqPfmucR789UVax2tsddHQ6MRplnnxCXNIyW4pqTqWvxmgsKihms46xsXUymQJ9fb6yCV4LVque7m0SEmqysW+fu660U4pYKM0z1ILbbeLQkUAxSFNAeJxOI23tToZv1ZervD4z3d1estk8uZyya0nL7THRFLKVc6ckqThLz+u1MDsbY2E+gddXJCq7eYF8fgsej5m11S16er3lEmil/6g0smY3lfHkqRAul4npqRhTU9rlw1DIitmsryqRwk5HoixLRMIpcrlClX+qFi0tduQKwtPZ6aS11UE4nOL27eL5aGu3UyhQNaaoFh0dxXKP12fGaNJxRyMQtrPTSSqVZ1Xg12tusdPX5yORzDJ4aakuSb6E/fvdbETTVYSq7Fdzm1lc2MTlNHFnbIOswGfnchoxm/SENT5XAOfOt3DphWpi/07FS7NR4lBFZauWYIWNEv7sztf5Wj5PqKJEmFdV9NuqznpexbcLwcpQKKfEL2VV9jlzpLMyTaEo8yEf/88XfwGbzfaGmNeXy+UYHBzEYrFw5MiRMrkqFAr843/8j7l69SpPPvkkwWDwdVvTM888w+c+9zkGBwdZWlri61//Ou9973vLjz/yyCP8j//xP6q2ede73sVjjz32uq2xgdceDYL1kOP//t//y9//+3+ft73tbbz3ve/lZ37mZ/D5fPyLf/EvCAQC/Pqv/zpGo5GVlRVWV1fJZrP4/X5CoRB+v1+TbA3fCvPtb43z1BMzJBI5bo+tb3f1uYlG01WlIL/fgsdr3pU8NG13BKIWU9K1OuuCQQsOp0kzpsDnt9DV5aFQUIhG01UeolqEmmxYLHqmt8mFFuFparZhMumZmRb7l0r5VdGNdFllKWVtlZ/TWlRUdiMhp/qbcDiMzMzE6hoHSmhvd6AoKgs1Xp8d/5FENJomsZm7qzJTio4AymXIyoDQpmYT6VSBaFTcGVdqUAgErFit9R2JAHv3uUhs5oQltlDIyqHDfpLJPIOXl4RdkF3dbtYj6aoyp04n0dtXVOVmpuNYbQYi4ZQwGBWKyfOrq1vEohncnu0g3JxSZZIvDZHeLSfs4GE/6VSeUNBKIp5jdDhcR9bOnGlmUKBeGQwSwYCN5cXq9+ldio+gSeWQY4fQTGXz7K0IMF1UlJpYhjwBg3YyeTinVkU61HqwChQw1RCsrYyOlqYN5g824/zZIGazmUAgQCAQwO12PxCylc/nGRwcxGg0cuzYsTK5UhSFD3/4w1y8eJGnn36apqbXd27id7/7XZ5//nlOnTrFz//8z2sSrJWVFf7iL/6ifJ/JZGqUL3/E0CBYDzlUVWVycpK//uu/5mtf+xqXL1/G5XKRy+X4i7/4C37yJ3+y/MWpqiqbm5usrq6ysrJCOp3G7/cTDAYJBAKaScjjdzZ49FvjfPtb4+VRKoGAlX1dblRFZX4uzuKi+KK/b7+bZCJb7hzcUQtM5ZLW/i43m/GsUJ2AnY7DUoxALltgeDhcFfDZ1e0mFt3dVzNwvgWDQcfcbFyo8HR1e4hupOuIYJnwyBJbqSLZ2a0hoLvHQySSKj+nrc1Be4eDjY10mfD09HgJh7c0fVQl9PR62VhP0dRsx2o1VEVPlNDb52VlJUlUMMg4ELBy5FiAxGaWocFlIeHpO+BlabGahMiyxP4uJ3p9jo0NFbfbytLi7oGmfQd8LC5sEo9nq0qBIyM7g50PHPQxL5hPWMLBQz4KBRWvz1I1Mqj2OaIB0aX3zO40cmd0g6UlsZJ2+IififFodRepy0RPrxdUlTujGxw+HOAlgS8Ltv2FF+rL0u9WfDQ7JLor5gVO5fLsrVCwFrKFKs/VRqGAT79dKqtQrwBWcyqhXQgWUoHtTcsEK6UYaPaFsf6jn6Dv548QiURYW1tjba30d10kWyKV+34jn88zNDSEXq/n+PHjVfaF3/zN3+TJJ5/k6aefprW19TVfy26QJEmTYEWjUb7xjW88sHU18NqjQbAaKGNxcZH3vOc9RKNRAoEAV65c4fTp0/zsz/4s733ve2lvb68iW8lksqxsJZNJfD4foVCIQCCAwWCo2//MdIxvf2ucR781TkFRGb+zgcmoo7vHQypVYPjWWtWF+9jxIOPjG5oXvhLe/o4OCnmF6amYUAk6djzI+J2NuqDNyqHOiqIyNrquGcYp2k8gaKSlxUZqC25vK3DHjhdHB9XO7qvdz/RUjM49znLmVC3Rutt+AkErx48HCUdSXL+6Kuxe1NpPZUlrdjaG32/l9tj6rgOtjx4Pcmf7OZWEZ/jWjsKzd5+ZxYWsMJW+tJ/0Vg6f38raWlJTTaw8Vi3MZj19B4odrCPDEZaXxeT86PEgt0erZxiWlNR4vBjhcPho/XNE+8nlChw46MPhMDE9HasqW2odqxZnzjaTTOZwO0wsLyaYm67+vPr8FgrZPJsaY6d+RvHTEdDTru58PqdzOfYYKmMZCrRWKFbxQgH3Nkuq9F8BrORUmioIViQHAXPxM6SqoNcVKPGxlZzCHkeejMmI07TGsf/xD3G17ygtqqoSjUbLZCudTuP1esuE67VISS8UCgwNDSHLMsePHy8TOlVV+a3f+i2+853v8Mwzz9DR0XHfj32vEBGsb3zjGxiNRjweD+94xzv4vd/7vYZH7EcMDYLVAFAck/NTP/VTvP3tb+dP//RPMRqNLC4u8vWvf52vfe1rPPvssxw7doz3vve9/NzP/Rz79u2rKgkkk8myspVIJPB6vQSDQYLBIEajse54iwubfOfbE3z72+O8tD07sHThzucVTCaZSy8t7xp7cPZcC5cv7UQjlKIElpd2DPYvJz7h7Llmblxfo7fPh8EgMzZaP/Pu7LkWBi+Luxubmm0cPRpgcTHJrZtrwu7FysiHEkpGc6ezaDTv7HRtq0S7REdsZ2Xl80p5tmM+V63KnT7TzJWhlV33c/pMExsbGQJBqzARXSvBvYRS+r7Xa+bKlZVdFbn+001cu7patZ8S4YnFM4wOhzl5qv45tTh1uonrV1dRFHX7vJmYmopWdQWe7G/ixrXd9zNwvoWCopLLKsK8rJOnQty8saYZ47G/y00waEWWZS69tLhr1MfJ/uKaK9+LllY7nR1OMqkCE6PrtLdbmbitrZD9vBTEbVHoMYsVrKVcgeYKgpVQCji3g0y3FBXr/9/efcdXXZ7/H3+dkXOyT3KyBwmEJISwNwEEBASZCWqL1qrVuke1tZbaWit+rbPWPavW6k/rIAwBpSIIKqDIHgmQhASSkORk7+Ssz++Pk3NyTnISsIahXs/Hw0ebc05OPidkvHPf131d7gHLqhDt9jdQvV5DaMegd4sd/Hw6PxeNGoj0MdOi16LTNTD389/0+Dqdf3g5w1ZDQwPBwcGusNUXdVs2m409e/YAMGrUKI9w9ec//5ns7Gy2bNniMXfwXPIWsN577z38/f0ZMGAABQUF/OlPfyIwMJDt27fLwOkfEQlYAnC0avjggw+44447uv0AVBQFk8nEqlWrWLFiBZ9//jmDBw92hS33TsngaOvgXNlqaGggJCTEtbLlrXNypamFTz4uYO1H+WzfVsLYcbHs32ciLT0MFMjx0jOqt/YJ4KhLGpweRlFhg6tg2htvpxu1WjXp6WH4+ftQkF9LSqqx148FnqNdnEXuXRubns74l0mT46isbPHaa8v1sXp57c6xO8YwP77ZXuq155T783RtZREXF0hCoqFjG7L6tNpdOGcGajSOFgyBgT4cO1aHqaJzqzVtsD9Hj7T0WDwOcMG0eNrbbZjNdnIPVXpdCZswMYZvd5R7bbCanBJKRIQ/Pj4qtn5V2muoHjc+ht27OgO8t35Z48ZHs3tXxSmfZ8/uCiIi/R0d9BvM3equxo6LZu8eU69Bd8SoEBrq2omOCqG+qp3C/DqPKcvXBsajWJpJC+isseq6glVusRHtFrBaFTsBHaGqyaYQqOl8vlqtBqOt83uq1GqlX0fRVZsdAt0Clt0XAjBTgx2/KBWL1t3Q4+voqr293RW2ampqvnfdls1mY+/evdjtdkaNGuVRlrBs2TLefvtttmzZQkpKynd63jPJW8Dq6tixYwwcOJDPPvuMmTNnnr2LE2eUBCzxnTg7v69evZrs7Gw+++wzBg4cSGZmJllZWaSnp7tqIcDRAsK5slVfX4/BYHCtbPn5+XV7/traVtZ/XMjaNfl8ueUEZrMdX18t6UMcxdqFx+pJSAzutZO3e/sE6CySb3Ab2XM6/aK0WhWjx0bT1GgmOFhPfn41VZWeK1vuvam8CQrSMTg9jBCDni++LPYocnfXUwsKR6+tQCorO2b9TfTsmO6NM4C5n8Tsug15qoAKMHVaP9rNNlpbvHfA7+15VCqIi9cTGxeKv58Pmz8/VWNUz+dxP5HonM94OtfsHOkTF+do2VFf19ZtTFPXIdJdabVqps9IoKnJTOGxeip62IbsKeyFhOpJSXGc5NTp1ez4xnsgdBo23MCB/Z71fKGhvgwcGILeR0N7s43hezXofds9AlbXPlgVVhtR2s6AZVHsrm1B9y7uAE1+WoLaOrcby202YnWO5262gcFtSLSPrxUtdmqxEDAkjPn//nmPr6U3NputW92Ws4bzdOq27HY7+/btw2KxMHr0aI9w9eijj/LKK6+wefNmBg8e/D9d35lyOgELHDVsDz30EDfddNPZuTBxxknAEt9LfX09a9asITs7m//+97/Ex8e7wpb7qR5w/DVrMpkwmUzU1tYSFBTkav/g7+/f7bkbGtrZ8N9C1q0p4PNNx/Hz1xIdHYiPj9rRvuFwDXV1noEnJERPTGxgj00rw8P9SBschk6nZsvm4h5XJwIDfRiQFOIqzHdKTg4hIjKAkuIGampaGZhsZP++nvtO+fppSEsLY+8eE35+WtKHhKNSqzjs1udLr1czZGjv4190OjVjx8VgVxSPoOjOOWrGW2h09bsK0aHVqvnyFLP+xo33HJLsUXeV45h/2FtPMqeMjFi2bz/pasFQWdXS7cTo0GHBHDzQc/8qnU7N1Gn9aGy0UJDv/RQpdO9e7+Q4RRpCW5uNgAAt27ae4pq7PI+zX1b5ySbXwYZThTRwBOYD+02ureejR7p/vQ4d1ns3fR8fFUkDQ5ly2A9DmI1Et6Wxrp3cq6w2wt0CloKCc9Gq1qoQ6hawqnzVRLi1kaiwWYnpKJBvsIJR77jPqkCgrxmVClo07YTMHcy0B2b0/KJP03et27Lb7ezfv5/29nZGjx7tUeP55JNP8swzz7B582aGDh36va+tr51OwCopKSEhIYFVq1axaNH5PURbnD4JWKLPNDY28vHHH5Odnc0nn3xCeHg4ixYtYvHixYwdO9YjbJnNZiorKzGZTFRXVxMQEOAKW95mhDU3W/jqi2JWrjjKZ58W0tRkQaNRMTg9nIBAH/LzavHz06Ci97YHMbGB6HzUHD/egCFEz6BBxm4je6Ki/AkI0LmGGHsTHu5HYn8DOp3GcTrNS+1SqNGXiAh/ryNZnKtL/v5a2s02du/sOVx1bQ4Kna0nnNuQOp2G5ORQ9u/vub+Xr1/HOJo9JpJTQomM9Ke0tMmj3cTphL2gYB3jxsXQ2GjucfSNRqNi9BjvYS8qOoABA0JobGwnIEDLjm96bsgJjjDjDHLuY5qKixsoKXbULJ3O6takSXHs228iLc1xsOFwbnW3Zran2saNjw8ifWg4JScavIZc1/N4CXsaTWet3fGiBoxhag4dbDhlSPvm65Ncb4tDE9BKul9noCrGSj86327SQmDHrp8CqFFcheoNPiqCLZ0f6ITNRqK28/uxym4jsqMpaZ0VwjsCVoMVogId/76KvoX4ey4iPavvV4icNZze6rb8/Pw4ePAgra2tjBkzxiNcPffcczz22GNs3LiRUaNG9fl1/a+amprIz88HHHVi//jHP7jwwgsxGo0YjUaWLVvGpZdeSnR0NAUFBfzhD3+gsbGRAwcOnJFDAeLckIAlzoiWlhbWr1/PihUrWLt2LcHBwSxcuJCsrCwmTpzosR1gsVioqqqioqKC6upq/Pz8iIyMJCoqisDAwG51Gm1tVrZ8foK1a/L5dH0h9fXtDE4PQ6fT4O+v5VgP2zrJKaHU1rZ1a1EAjll9gzs6uZ843kBxDyNMwNEvymyxe5wic7RQCKa6upWjR2qIi3dcd0kvYS86JgC9TkNJSSNpg8MICtJReKzO1ZICICLCj6Agfa9hLyExmP79DTQ2mnss1jYYHCt7h3O7r+wlJAYTFxdIXV07arWq2wBkd/7+Wo8gp9WqGZwehp+/lqNHKqmrtaL31TB4cDh79/Qc0nx8VAwfEUVBQW1Hzykbhw5VYW53L/6H9CEhHDzQ82tPGmhgYHIohcfqeu1v5h7SnDq3ULWnX2vnFuSMYb4kp4TS3m4j1y2gn07YGzo8mNoaM/36hVJV1er12t3D3k22eNSBLaT5uo3G0SpEWju/N6ptVsI0jvvNioJvZ36i1Golzm1LrchsZYDeraWD3UZYR8CqsUCkr+NrqM6uIsbfsermG9TIyPduICjqzA5Jbm9vp6qqCpPJRE1NDSqVCrVaTXp6OhEREa6fB6+88grLli1jw4YNjBs37oxe03e1efNmLrzwwm63X3PNNbz00ktkZWWxZ88e6urqiI2NZfbs2fzf//0fUVFR5+BqxZkiAUuccW1tbWzYsIEVK1awevVq9Ho9CxcuZPHixUyePNmjlsJqtbp+uFZWVqLX610rW8HBwd3ClsViY+uXJaz/5Bgfrc5z1RmlDjISFuZHcXE9JcVNjBwVydEjvbdPGDY8gsLCeqwWO4PSQmltbaakpJ2W5s7Akp4eRmlp7z2cxo6LRu+roba2ndxDVV5XKJIGhtDYaKayS+8u98amzc2O3l49zcwDx0k0tbozyPn7O9oYaDRqV+1SVJQ/fn4+3UbNuAsL9yMkRE9Tk4UBAww0NHYv1j7VkGSVCoYNDyciMpCjh6t7XEn089eS4mW1zVmgr1KrOJZfQ2xcAAcP9HxAQatVOWZXdowhiokJINEtaNrtjpA2dlxMjzVyThMzYqmrayfU6EvxiXrXypi7nrYgobNmLCzMl+3bSmls7Lndx9DhwRzc77klGhMT4AjJTWZyc6oZPyHWI6TdaouHwBYGuQcstZ1Ie2eKqrPZCOn4w8WsBl+3L7xii5V+7oOhLVb6u/XMalA6WzpUWRSifR3/8A0+WqI0LVjsoAttY9bG23t8XX1NURT2799PfX09oaGhVFdXs3TpUhITEwkNDWXVqlV8+umnZGRknLVrEuK7kIAlziqz2cznn39OdnY2q1atQlEUFixYQFZWFtOmTfNo6eAsiq2oqKCqqgqtVuta2TIYDN3Cls1mZ/u2UtatKfAYRn3hzATa22yUljZyvMh7rc/4CY7TYF2P9bsXiivAvj0m2nsYgQJ0C3JGo2NAcGubjZyDjj5fQ4aGc+J4Q68NMtMGGykvb8YY6kdUTIBH6wmngckh1NW1e12Rc177hIw41GrYv6+y2/gYp9i4QNSqzpE1TqGhvqQOMtLWZqWqqgWtVtNr93pjmC+hob6uZp4DkgxERwdiMnU2+AwO1hEbG+gaDeRNQICWgcmOPkv+/j7kHa2lutrzNep0KpJTQ8g56H0CQGioL6lpRgIDffjqi+Iee3Op1TBmbEy3rcz+HYcLTJUtFOTXMn5i74O4oXPlysdHzeDBYfgH+HSbLTl0WBAHD/S8qglwwdR42tps2OwKh3OqaGmxcoetH/agJlL1bn2vrBbitJ1vN9ntBHZsw7eoFNzXmY5bLCS6ba11DVgt2F2nDE1mhdiOpqON/j5E2ptpsoLfIF8ufv+XvV57X1EUhZycHOrr6xkzZgx6vR673c5nn33GE088wfbt2/Hx8WH27NksWrSIhQsXnvVu7UKcigQscc5YrVa+/PJLPvzwQ1atWkVraysLFixg0aJFzJw506Olg91up7q62lUkr9FoXKcRQ0NDvbaW2PltOVu/LOb/vX3ItcKT4Cy2dmtyeTrtEyZmOPpgDUpztCHwNrKna1+uroKCdEzMiKW2to2DByq9buUBjBwdxeGc6m5NK52ja6qrW9H5qCksqu+1CWvaYCNlZc3U17W76n+6bkMOTA6hvq69x8JxcMz602hVhIX5oSiQ2/FL311MbCAaTc9borFxgaSkhGK1KWz7qqTHuiNvq2RdG6PW1bYRHeNHQX7PQcXXt6PebK/J64lE6Nym7G0Qt1oNkybHY7UqNDa2czi32uu/r7ctSHCs6qWkGjEa9bSbm9mzq+difuj+tegcQj5rjx9KSBOJ6s5QVG61Eu22+ttqt+PXEbDqbDaM2p5bOpywWEl0C1hmlR3fjhOHFWaFuI6AVa9TE61uo8asInx+HDMfubjX6+8LiqKQm5tLbW0tY8aM8fg58MEHH3D77bfz0UcfERsby+rVq1m9ejV79uzBZDIRFBR0xq9PiNMlAUucF2w2G9u2bWP58uWsWrWKuro6Lr74YrKysrjooos8Thna7XZqa2tdvbYA18pWaGioRzG90949Faz9KJ91a/NdK0H9EoJISwvjxIkGjvSyouKtpkalcoxzCQnxpaionv4DDKcMac4WAorivh0GuYeqaG52BJYJE2PY+W3vDVbHjIumoqyZ+H7BNDS2e513N2JkZK/d2VNSQ0noF0RxSVOPW37gGMVTWdniMcdP76shNTUEs7mVk6VmwsL9aW62dtvudBcb51hPOVna1Fmg32Yl91Allo7i64gIPwICdL1uZTpaIISi9dH0OPrGP0BDYqKB3Jzur8vHx9GrKyBAByr4updaqa5bkICrqatzmHZ7u41xE2LY8XXvW5BDhgZx6GAjCQnBxMUHUVPT2u1rrreg/3tbIpbgRpLcZg+arFYi3bfX3cbhVNtsRLgFrEKLhQFuAavYYiXBLWAp6s4Th+VmhfiOgFWr2In1s1JtV5P6x3GM/vmwXl/n96UoCocPH6a6upqxY8d6hKuVK1dy4403smLFCubMmePxfnV1dYSEhJzRaxPiu5KAJc47drudHTt2sHz5clauXElFRQWzZ88mKyuLiy++2OOUobMvl3Nly2azuVa2wsLCvIYt5zDqI7nVrFtbAEBYmI7IKB8URc+RwzUoimOLbdjwyF5XODQaFWPHxVBT00p4uD8lxQ1ea48mTorl6x7qd/R6DYPTw4mI9OPbb8q6HeX3eB4v7QHctyFzD1UyclT0KTu4jx4dxaGOdgv9+xuIiQ2k0tRMvltgGTosgsJjdb2ODxqcHoZer0Hvq6WwoBaTqftK2IAkA40NZq+rZIFBOtLSjGh91FSUN/c40Bq8B7DYuEASE4Op72hdERjkg8GgpaS45xU5f38tA5JCyDlUxaBBRkKNft3+3XQ6NelDInot1A8I9GHChFgaG82u5qTepA8JJOdQ95quiEh/kpJCaG21EBioY1sP4UqlwD32/uhiW4kwd/7D12InlO5f3wCVNqtHT6xjZgtJus6AVWKx0k/X2QFdrcF14rBGqyayYyRPE1YifO3U6X2Yt+bnBBi7967rK4qicPToUUwmE2PHjvXok7d27VquvfZa3n//fRYsWHDGrkGIviQBS5zX7HY7e/bsYfny5axYsYLi4mJmzpxJVlYW8+bN8yh8VxSF+vp618qW1Wp1NTIMDw/32sjwyOEqXn9tK19uqaTwmGMFJizcj8HpYfho1XyxpedeWX7+WlIHGdm3x7MPVv8BjsBSUd5M8Yl6RoyMcjU99UathnETHDU+zlN5/h1d5N1Dibeu81256nc6+lV5a2za21ZmTGwgif2D0fmo+ebrsl7rzYYNj6Agv9a1XeheoO8MLN6GP3c1YICjML2xyUx6ejhaHzV5XXpGxcYGgsqxAtaTgckhxMUFUVff7rEy5i442IeY2CCvK5b9BxiIjQmkuqYFnU7brQeaOx8fFcOGR7raWWi1atLSjAS6bcE6VjkDyc3p+ZrBsUJ68EAlg9KMKMDhnM4VTQCtouJ39kRshgaPvle1NhuhHV/TFkXBx22bvNxmJdYtYBVYLAx0W8Eqs1qJ9el8X73bnPYii5Vk347vKY0Ffx+FGqMfSz69stfX8X0oikJeXh7l5eWMHTvWY8V6/fr1XHXVVbz99ttccsklZ+wahOhrErDED4aiKBw8eNAVto4ePcqMGTPIzMxkwYIFHrVYiqLQ0NDg6iLf3t5OeHg4UVFRhIeHo9VqaW9vZ+/evWg0GkaMGMHJ0hbWrsln8+fHKT7RSFFhfY+9soxhvoSF+XVrmukuMNCHIUMjUKtVVFe1eh3Z01vfKbVaReogI6FGPT5aDV9sOVU3dM9Tbu7jX1zd0E+j3mxCRizfflOG0ehoQ9DcbCE3x7OT+5ix0RzYb+p1/t7Uaf2w2RXKTjZ5nXEIMCjNSHlZ9wDm7HEWGOhDU5OZioqWXrcgo2MC0GrUrkJ958qYgmMLtqXFSrBBS4C/mrKyng8XBAb60C8hmNraNgb0d5ymzO2yBetY3Qpn756eG8ympIYQbLBTdtLCydKeV9OcjVjd6fUa0tLD8NVryM+vI32AkYyvfcDQQJxbwGqw2wjuqMmyqMHH7RpP2q3Eu/1BYdKriGzv/Pcrt9qI6WjLYFGDXtV53zGzhVQ/NXbAX+9oMlo5MIhfvL+kx9fxfSiKQkFBAaWlpYwbN84jXG3cuJHLL7+cN954gyVLzszHF+JMkYAlfpAUReHIkSOusHXw4EGmTp1KZmYmCxcu9OiXoygKTU1NrrDV2tpKSEgIjY2NhIaGMmzYsG5bid6GUQcG6UgbbESr0VBR3tnV25uICD+CDXqPGqGo6ACSkkKor28jN6eaoCAd8f2CyDnkves8eHaCd3YUP1nS6DGjsLcO7k46nZopU/vR3GTuNjbHXU89nAKDtMTG6vD188PfX+/6nPRk9NhoDroFsNi4QBI6tvIOdzToPJ0tyJTUUKoqW4mI9CcsrPtWHjiK8NvbrR79w9zp9RrGjI1Gr9eyZ085dbXeV9OCDTqiogK6heaQUL2rV1fhsTr6JRh6Xd3SalUMGOhH3hHH9fTrF0R8v2Bqa1s5nNsZsnsqjHc3aXIczRXtzDkSiD68iXC3LcEWux3/jq9b9xOEACesFvq7hbFitY1+dre+V1oFY8fiZIsaAt0CVqHZQoqfmmYbhAeYsaJCs6g/s+8/MzPyCgoKKCkpYezYsQQEBLhu//LLL7nssst48cUXueqqq87IxxbiTJKAJX7wnH8BZ2dns2LFCnbv3s2kSZPIzMxk0aJFxMTEeJwyLC4u5ujRo2i1WiwWC0aj0TWM2r1NhJP7MOqqqhbKTjbT1mbtGHvjWaQOjkak7WZbr/2rUgeFEh0TSG11Gzk5VV6360JC9ERHB3htaeCsm6qubsHP36fbNqW7rgHMOTYnONjzRGFvfZ6cMibFsm+vYxC3Rq32OJXnNGFiLN/u6DmAhYf7MWp0FFVVrRzYb/I64xAgfUgYx483dDsp6V4zpgC1tW09BkZwhDtFgbKTTW7d1B3NW50NaYODNfgHaCjvZXUrIEBLcooRrVaNWq3y2sXex0dFYn8/8vO8h72ICH8GJocQGOTDls9PeN3GdHKG3WBFw832fviENBLptu1nVhR0HV/XdXYbIW4nDIusZpLctgTzLGZSfDq/tk02C1EdBfK1Njthus7vj0KLhRRfNdUWiA8yU++jZcKLc+g3KqbHa/1fFRYWcvz4ccaOHetRW7l9+3YWL17MU089xa9//es+/7hCnA0SsMSPiqIonDhxguzsbFauXMnXX3/NuHHjyMzMJDMzk02bNvHYY4+xdu1aBg4cSEtLi2tly7mi5SyS9zayoqamlf9+4jmM2lmkrtOpaW+3UlTUQH0vher9BwTT2tK54uJtGzIqOgBfvcZjpaqrkBA9UdEBNDWaSUg0eD2Z5uevJTXVyL693gOYY/SMkYSEYHJzem4OCt4DmHufsKNHa0lLCztlF/PxE2LYtdNxUtI149BqJye3s2ZsxMhIjhyu6daqwt2gNCMWi52oKH/q69vJzek+uiYxMZiW1p5POCanhBITG0Bri7XXOrngYB3RMYEeJy6d/a78AnwoyKulsbGd2Hg9hQU9bwm6990KCtIxaLARxa6Qm1Pt0frCfSUxVNFygz0e39BGwty2/RTAGYtq7DaMbgGr0Gr2qLnKt5hJdgtYNXar67mqbDYide5DpC0M9FVTYYb+wWYK1XDjjut7fE3/q6KiIoqKihgzZoxHe4Vvv/2WRYsW8eijj3LLLbf0+ccV4myRgCV+tBRF4eTJk6xYsYIVK1bwxRdfoCgKl1xyCQ888AADBgzwWNlqbW11nUasr6/HYDC4usi7Hxd36jqMevDgMI4crWFgUgj+AT4cPVrTbWUlfUgYJcWNXuf3geNk2rjxMdgsdnbuKqe1h87zPQWwyEh/V5f4kycbiYwM6LUFha+vo8+Ss57I2Ry0oqKJYwWOLdDT7YY+aXIcdXXt3VbG3E2c5Cjm9/ZTx1kzZgj1Ze+uCo/WEF0NHRZO4bF6j+1FY5gvKSmdpykT+xuoqW6jpocGq+BZPO/cyusaVAMC1ISE6igt6fl5/P019B/gi06np7rK4jWoajQqRo6OYpeXIOfsd+Xrq0WnU/PlF53DuMMVH66zxxEQ2ujq1G4Hj/ODVYqNcJV7UbuZFLdTg12L3OvtVtdzVVhtxOg7n63SbiXGR+UKWKX9gvjVyr6tfzp+/DjHjh1jzJgxBAcHu27fs2cPCxYs4IEHHuDOO+/s048pxNkmAUv86Nntdu6++27efvttrrvuOvbu3cvmzZtJT08nKyuLzMxMUlNTPcJWe3u7a2Wrrq6O4OBgV68t9+PjTs3NFjZvOs6aj/LZ8N9CmpstqNUqBqc7mnseK6glvl8whw45WiP0xD2A+fpqSR/iKFLPzalyDSbuPyCYlmYrpl6KvqOi/AkL9yMwUEd7u40cL6fqgoN1xMUHkZvjvQYsIlJPSorjl/6mjSd6/FgqFYyf4Ggf4S4lNZTwcH9KSxo5caLhtGb0ObcXHUXuYfj5+ZCfX+vRrX7kqEhyc6t7/TwOHxGBn58Wq01xFbl31VvtVkSkPwMHhmA2W6mtbaPwWM8rif4BWsLDtZw43hnA3DvB5+fVotWqGD4istch2uCoy9rxTRlpg40YDL4cP16PvcTM1fZYDMYmV51Vu6Kgd/t6LbNZidF01lxVB6qIaO6sej9mMZPktoLVjI1AleO5yqw24twCll1rR6coNPhpiLC3oCwayMV/ndHrdX8XxcXF5OfnM3r0aAwGg+v2/fv3M3/+fP74xz9yzz339NnHE+JckYAlfvR+9atfsW3bNj755BMGDhyIoijU1NSwevVqsrOz+eyzz0hJSSEzM5OsrCwGDx7sUfRuNptdK1s1NTUEBga6Vrbci3KdnMOonWGrvr69c9ZdqC/Hi+o5ebL70f3RY6J6DGDOrbiQUEfhfG9DpBMTg2lrt3kMvA4K0jEozYjdrpCTU0VQoO6UQ6QDA31I7G/g0MEqV+Bo7HKqTqtVMWKU91UZd9NnOMYVuY/N6aqnGjBHzZgjcKhUKnZ8c7LXHl9DhoZTVNi5uuUcPq3TaTh6pJq6unYGJBloaDD3OGYIHCFVp9PQ0GAmdZDR0frikOcwbX9/NaFGLaUlPddu9esXROogx+ijricS3U2Y2D2kAoyLCePCkiDCI5rRK45Q5V7gDt3H5uRbzaS6rVhV+UK42wKcVaXgvLfUYqWfr2M1q9WuEKi1o1JBuWIhQGtn5oeLiU4N7/H1fRclJSXk5eUxatQoj8agOTk5zJ07l7vuuos///nPffKxhDjXJGCJH73NmzczdOhQwsO7/5Jw9s5as2YN2dnZfPrpp/Tr149FixaxePFihg8f7hG2LBYLlZWVVFRUUFNTg7+/v2tlKyAgwOsw6m1flfLR6jw++bjAtWWYnBxKZJRjdef48QYmZjhWbnrr4D5yVCSHc2uwWGwMTg8nIKB7r6zUQUZMpuYeT8qBY9B0ZKQ/NpvitUgdINToaEORn9e9DUVoqC8pg0Ixt1tRqdTs2d3zqoy37UVvJwpPq31Ex+rWgCQDkVEBlJ1spKjQc2VpxMhIDh/ueXVLo1Ex+YJ4FAWOHq7u8eShe2G8O/dVxZKSBlQqCydLew5Xer2atMHhrho49xOJuTnVtLXZUKlg3Piet2ATFF8ut0cTHdGCpuPLo0Wt4G93O7hhtdDPPWBZ2kl1O7DRdRahgkLHZBxKbDYSOmqwGnxUGO2O1b5azJgNPtyw9ZoeX993UVpaypEjRxg1ahShoaGu248ePcrFF1/MjTfeyIMPPtgnH0uI84EELCHcNDY2sm7dOrKzs1m/fj0RERGusDVmzBiPsGW1WqmsrMRkMlFVVYWvr68rbAUFBfU4jHrtR/l8su6Y2zDqRNrarFSUN/fYL2r8xBh2eRmh4z6yx2azcfCA9+0wp64Dop0rY1otHD5cRXOTo8Ber9dwopcCe+f2YnFxI2lpRuwdMwrda8ZOZ9af80RheXkzOYe8n6aEnle3+iUEEx8fSHV1G4FBPhzYV9ltYLe7welhFBc30tQxaDslNZTwCM/WF6dq+wAQGqrHz18hKMif0FB/jnnpYq/Tq0hKMnA4t87rczjGJYVhDPPjm+0ne6zLS1L8uMweSVx45/PX2m2EuhW1n7BZSND0HLDcA5hNUXCbosMxi4VkX8f2YqWPipiOgGXWtKNM7sfPXvz+8wfLysrIzc1l5MiRGI1G1+0FBQVcfPHFXHXVVTzyyCPdvmeE+CGTgCVED5qbm1m/fj0rVqxg3bp1BAcHs2jRIrKyspgwYYJHZ3ibzUZVVRUmk4nKykp8fHxc24gGg6HbLw67XWHnt2Vs+6qEt986RGlHg0zXQGe3xqSnU7s0dlw0+/eZSEg0EBHpT2mxo+7JXfrQcE4cb3CFi640GhUTJ8Wi1arJOVhFZaX37bOwcD8MBn23MOi+ulNUWEdMTCD7e+kX1XV1y2DQkzrIiNVqJzencyvudFa3xk+IofhEAwn9DTQ3mck51H0rbugwR+f5nuYzJiQGM3CgY/j17l5W5cLCfNFobJhMnSt/zqHOzl5d1dUtxMb5k5/X81auWu3oF7ZzR7nHicRj+bUen/uFqfGk5qpJcNvjq7JZCXeruaryA7f8Rb7FTKpbkXup1UpcR1uGdkXB1y1gFVgspHQErCKzlWQ/FTZFwU9vZuAzc0i5IKHH13A6ysvLycnJYcSIEYSFhbluP378OLNnz+ayyy7jH//4h4Qr8aMjAes89sUXX/DEE0+wa9cuysrKWLlyJVlZWa77FUXhr3/9K//85z+pq6tj8uTJvPTSS6SkpLgeU1NTwx133MGaNWtQq9VceumlPPPMMx49Z/bv389tt93Gt99+S0REBHfccQd/+MMfPK7lww8/5C9/+QtFRUWkpKTw2GOPMW/evDP+OThftLa2smHDBlasWMFHH32Er68vCxcuZPHixUyaNAmt29Bdm81GTU0NFRUVVFZWotFoXCtbISEhXn+ReBtGHRMTwNDhEZQUN/ZYiA7e5xOC58iekBD9KQvsU1ONmCod24uO9g1h3WrGYmID0WhUvdaABQfr6JcQjEajws/fh/y82m61Tqda3XIOww4L82Pb1hJXgf/pvn7nVpyz9UX6kPBTFsYnp4RQVdVKXW27oynsAAP1jWaPYdoRkb4oio2qyp6vJzDQh/Qh4Wg1aleRe1dqDYwYEcme3d3bZ7iPHPL11VD2WTVzMdI/rHPbt8JmJcotYB2zmknSdq5YlekV4txydK0WQjtyZZPdTpCm82sw32Im1dcRxkotFhJ91TTYFPRG+Nn33B6sqKjg0KFDDB8+3GOLvqSkhDlz5jBv3jyef/75n3y4UhTlJ/85+DGSgHUe++STT9i6dStjxozhkksu6RawHnvsMR555BH+/e9/M2DAAP7yl79w4MABcnJyXG0F5s6dS1lZGa+88goWi4Vrr72WcePG8e677wLQ0NBAamoqs2bN4t577+XAgQNcd911PP3009x4440AbNu2jalTp/LII4+wYMEC3n33XR577DF2797N0KFDz/rn5Vwzm81s2rSJ7OxsVq1ahUqlYsGCBWRlZTF16lSPZqV2u52amhpXkbxKpXL12QoNDe11GHXe0RrWrM4HOhtUNnVZnTmd1a3xE2IpL28iLi6I6upWj15OTqfqqj4wOYR+CUHUVLexf1/Pq1LeVrfUahWD0oyEhOg5dqye+vo2UlPD2L+v5+ao7icTdTo1g4eEo9dpyMurpdat7cLpvP6JGbFYrXavc/6cBqUZKTvZ5HWbrrPmzExpaT2Vpp63YL31y4qOCfAYu6NSQXJKIEcOn3pG4fZtpUwzhjO2zp8EQ+frLrNaiXEL9QUWMwPdTgl2bdPQ6ANBHf+09XYbIZrOr7s8i5lBHQGr1m4hwkdNjQqC58Rxyd//9+7tJpOJAwcOMHz4cCIiIjqvvayMOXPmcOGFF/LKK694/R74KXEPVyUlJcTHx5/jKxJ9RQLWD4RKpfIIWIqiEBsby913383vf/97AOrr64mKiuLNN9/k8ssvJzc3l/T0dL799lvGjh0LOAanzps3j5KSEmJjY3nppZf485//THl5uSsY/PGPf2TVqlUcPnwYgCVLltDc3MzatWtd1zNx4kRGjhzJyy+/fBY/C+cfq9XKF198wYcffsiqVatob29nwYIFZGZmMmPGDI9mpXa7nbq6OtcwakVRiIiIICoqCqPR6PUXTd7RGtatKWDd2nzXeJbQUF9S00IJCtKduhu4l+21qOgAYmN9qa5uovhEO6NGR3HoYFWvg53di+cTEoOJjwvCVNlMfl6d6zHRMQFotepTrm6lDwlHpVK52jd0pdGoGDXa+4BsjUbFoLQwgg06dDoNX2zufT7juPEx7N7VWbvmaAobhk6v4eiRGupq23vsGO8uJtaf1lYzZjMMHhyOSuWoOXMPayEhesIj/L2uWDlFRvozdHg4NTXt5ByqxNzuvV5s4qRYvu6oORthD2SaysBAY+f1VWsVwqyeq1DujUSPWc0kuxW119hsGDu2tJu0EORW61bppyLKbEdRFFDb8FGrOKlR+Pknl2CM7WwA+l1UVlayf/9+hg0bRmRkpOv2iooK5s6dS0ZGBq+//vpPPly5u/TSSxk4cCCPP/44drtdPjc/AhKwfiC6Bqxjx44xcOBA9uzZw8iRI12PmzZtGiNHjuSZZ57hjTfe4O6776a2tvMHvtVqxdfXlw8//JDFixdz9dVX09DQwKpVq1yP+fzzz5kxYwY1NTWEhoaSkJDA7373O+666y7XY/7617+yatUq9u3bd4Zf+Q+HzWZj69atLF++nFWrVtHQ0MDFF19MVlYWs2bN8hhiqygKdXV1rpUtq9VKREQEkZGRhIWFedR3OR0vqmfd2gI+WZeP3Q67dpYTFKQjbXAYVqudnEOVtLv9wj6d1Z2p0+Ixm+00N1t6LDLvbXUrJjaQxP7B2Cx2Tpxo6L0w3MvJROfYG2f7Bp3OMfy6t5OJ7q8tdZCxxxmFPW2dOmk0KqZN70d7u438vNoerz2+nz+NDe3U13sGUOdQZr1OQ0VFMxqNusdDCoBrJc451iggwIdBg8NQq+FwTrVrG3RwegC5OZ0tNkbbg8hQBZFq7AxzNXowuh0ULbBZGOhW5N61k7v7YGiTzUqU28gdZ8Bq0agIxvExShICuPXjS3t8Lb2pqqpi//79DBkyhKioKI/b582bx4gRI3jrrbe8fo3/lC1ZsoTPP/+cPXv2EBcXd64vR/QBicg/UOXljr/u3X+AOd923ldeXu7x1yOAVqvFaDR6PMbbc7h/jJ4e47xfOGg0GqZOncqzzz5LUVERn3zyCXFxcfz5z39mwIABXHXVVWRnZ9PU1IRKpSI0NJRBgwYxZcoURo8ejU6n4+jRo2zZsoX9+/dTUVGBzdb5Sz2xv4Fbbx/Nmk9+zj/fmMtDD09lyLBwdu0sZ8/uCrRaDWPGRTNmXDSTJp86XGVMiuOLLSV8vf0kB/ZXEhikY/yEGEaOikTXcWx/9Jgo8o7W9Lh1WHayiarKVvLz67DbHaFm6LAINBrPepKoKH+Cg3TdVneKiurZvq2Ugvw6kpJCmDK1H60tPa8kqVSOdg3O13b0SA3bt5VSXNxI/wEGMibFMTA5hIxJjkHKvf35OGx4BFu/KmXrV6VUVLSQOshIxqRYEhI6O4snJAZQX9c9XAG0t9vYt8dEQUEdGrUaPz8tGZPiiIru3hvN2THffWZkc7OF3TvL2bmjHLPZxvCREcye0x9TheeqlgYVisrzhTR2/ffoUr4T6O/j8bbW7QFdX0lToyOpVbc5nrPJbmfmnyd2ew2no7q6mv379zN48GCPnxk1NTUsWrSIwYMH8+9///ushqsvvviChQsXEhsbi0ql8vhjEhx/7Nx///3ExMTg5+fHrFmzyMvLO2vX53TttdeiKAqvvvoqNpsNWfv44dOe+iFCiO9KrVaTkZFBRkYGTzzxBLt37yY7O5uHHnqIm266iVmzZpGZmcm8efMIDg7GYDBgMBhISUmhqamJiooKCgoKOHjwIOHh4URGRhIeHo5Px6pEbFwQ1980kutvGkmlqYWP1xWwbk0+O78tY1BaGLt2lTNqdBRardrrUGJvq1v1de2uE30BgT5MuzCB2to21Jqei2/Th4Rx4kRn24PKSscqUEio40Rge7uN+ro22ttsvc5VDA7WodNr2PTZcaCzk3pTk5ncnGpsNgWNRsXoMdFem3ECFBXWU1RYT8akOI4fr2fipFjqah29troaPTaaA/tMHi0d3OumEvsHExvrS1lZA42NPW+dRkb64evn061ha3JKKJGR/pSUNGIyNZOcbOy1ds1stuPn58On/y1yTQAICdFz/HgDmmIVXTcS7V1++So2xePP5a7/Ylq3AuquM7gNHfVYZsUOaKjpF8igyd99BaWmpoZ9+/aRlpZGTEznYOj6+noyMzPp378/7777rseBkLOhubmZESNGcN1113HJJZd0u//xxx/n2Wef9ahlnTNnjkcta1/quv1ns9nQaDRcfPHFjB8/nvfee4/77rsPjUYjxe8/cBKwfqCio6MBR02D+w+ziooK15ZhdHQ0JpNnIbHVaqWmpsb1/tHR0VRUeG7HON8+1WOc94veqdVqxo4dy9ixY3n44Yc5ePAgH374IU899RS33norM2fOJDMzk/nz5xMaGkpQUBBBQUEkJye7wlZRURGHDh0iLCzMVSTvDFsRkf5cc+0wrrl2GLW1raz/2HMYtY+PmuTUQHy0UFFuISX11AOZhw+P4LNPi1AUR/uF0WOi0GhUHM6tdjUmdTY+9TaQua62nR1flzFggAG7DeLig4iJC+rWKwscW4dGo69HEKo0tbgGNIeE6hmUFkZQoA9fbOm95mrSpDi2dby2k6WOInLnAYHmJgs5OVWMHhPF7l0VvTZ11WgU9u6torXFTkxsIP37B3cbKB0VHYCPVu21X1h+Xi35ebX4+2sZMSIKjVpF6iCj1wMGABMmxvDNdkdwtHcMf3YaHRqNr1WD+9qT0uV3btdX0t5qAbfGozq3X9JavRpnYmtXFIwdv+xVKmiyK8z9v0k9fl56UldXx969exk0aBCxsbGu2xsbG8nKyiI6Opr333/f9TV7Ns2dO5e5c+d6vU9RFJ5++mnuu+8+MjMzAXjrrbeIiopi1apVXH755X1+Pc5w5Sxo12g0rtD14IMPMm3aNB566CGWLVsm4eoHTrYIf6AGDBhAdHQ0GzdudN3W0NDAN998Q0ZGBgAZGRnU1dWxa9cu12M2bdqE3W5nwoQJrsd88cUXWCydWw4bNmxg0KBBrm7LGRkZHh/H+RjnxxGnT6VSMWzYMB588EEOHDjA3r17ycjI4OWXXyYpKYmsrCzeeOMNKisrURSFwMBABg4c6FoNCwkJobi4mC1btrBr1y5KSkowmztXp0JD/bjiynTeeW8RB4/cwDPPz2DMOAPFx1soyG8haWAozc0WJmbEEhbefaYiOFe3OrfX2tqs7N5Vwbc7ymlvtzFiZCQzZyVSUtLoNVw5pQ4yUlPbxokTDez8tpzdO8tR7DBqdBTjxkcTFORDZKQfwUG6HsfnALS1WmltsfDZhuP46DSMHRfNmLFR+Pt7/n2YkRHrClfuKitbHNugByrJmBSHSqVi+PAI9HrvP/6SU4I4WdpMa4sjhZSdbGL7tpPkHKom1OjLhImxjB0fjU6npqSk54L+gAAt/QcY+Obrk2zbVsrRIzVERfkzMSOWIUPDUaudpyVj+ObrngdpN3a0zXDn5+cZVLr+Gla73WLtstql1XVuz1XZbKg7WrrrVWAeE8HA8bF8F/X19ezZs4fU1FSP2qHm5mYuvfRSgoODyc7O9jjwcb4oLCykvLycWbNmuW4zGAxMmDCB7du3n7GPe/vttzN9+nSWLVtGVVUVVqvj+yghIYELLriANWvWUFrq+FqWrcIfLilyP481NTWRn+84pj9q1Cj+8Y9/cOGFF2I0GklISOCxxx7j0Ucf9Vja3r9/f7c2DRUVFbz88suuNg1jx451tWmor69n0KBBzJ49m6VLl3Lw4EGuu+46nnrqKY82DdOmTePRRx9l/vz5vPfeezz88MM/2TYNZ4KiKBQUFLB8+XJWrFjBnj17mDx5MpmZmSxatIjo6GiPv2ZbW1tdw6gbGhoICQlxrWw5/+3b2trYvXs3AQEBJA0YxLatJ1mRfYTPPi1yDaN2b59gqmhmwkRH7VJvnAOJVSpcI3uOFXg2x+w6D9CbxP7BREUFoFLB0aOe7RecAgK0JPYPIedQVbf79L4a0tPD0WrV6PQatn5Zcsrrdi96d/baUrkVmaemBlF0vAlze88/Fvv1C8JssdPSbCFtcBg2m53c3GqPlbnAQB/i+wV73Z50Mhp9GT0mmqrqFnIPVXkcUHB3ZVQ/AirbGdI5F7nbqcFyvUJ0e+fXh8lmIbpjK65VseOn6gyTxyxmBna0cDipg/iOlbyaYBVXfHoJAYbT3xarr69n9+7dDBw4kISEzoakra2tXHbZZQCsW7fO44DHudT1sNC2bduYPHkyJ0+e9NgJ+PnPf45KpeL999/vk4/bdVvwtddeY+3atWzatIno6Gguvvhifvvb3zJgwAC+/fZbJk+ezFNPPcVtt93WJx9fnBsSsM5jmzdv5sILL+x2+zXXXMObb77pajT66quvUldXx5QpU3jxxRdJTU11Pbampobbb7/do9Hos88+22Oj0fDwcO644w6WLl3q8TE//PBD7rvvPlej0ccff/wn1Wj0bFIUhePHj5Odnc3KlSv55ptvGD9+PJmZmWRmZhIfH+8Rttra2lynEevq6ggODiY0NJSysjLCwsK6Da9ua7OyedNx1q4pcA2j1mpVTJoSj8Vs93oiz6mnk4mdjUn12O0Ke/eaem3qmZgYTEur1bUNqNGoSBscRlCQjsJjdVRUtGAw6ImKDuhxW835fqPHRLNndwWD08Pw9/chP797Y9NTdYPX6dSMHmOkvqGVslIrdXXeZzkmJgbT0mJ11Zo5+fo6xt5otWpOljYSEKjr9brVahgzNoZvd3TUvPVwojBjUiyBX7XR30fL0M7a+24B6wRWEtwqPmrsFlen90a7nSC3f/8Ci5nkjoBVaDUzUO+DRVFIfmIiYxYm93jNXTU0NLBr1y6SkpJITEx03d7W1saSJUtobW1l/fr1Hj9rzrVzFbCc1qxZw+zZs9Hr9dTU1FBWVsYDDzzAjh07qKio4Ne//jUzZsxg7dq17Nixg5UrV3r8PBc/LBKwhDiPKYpCaWkpK1asYMWKFWzdupVRo0aRlZXlKhx2D1vt7e2cOHGC48ePoygKwcHBrpWtgIDup9ssFhtfflHMjq9P8ta/D7qGUSclhRAV4zlQ+bRG9oyPZt8eE4n9ex7Zk5wSSnVVK7W13VeswBHWRo2KIiTUlyNHqikt8d6Q08dHxbDhkeze5VkfqFarSBtsxGDQU1TUQP8BhlOO2hk8OJi8vEasVsVr2APoPyCYxkZLt/DmzmDQEx0TgE6nwT/Ah4I8z2HcjuvrHJHjjU6nJi09nOioAHbtKmecyZ94HzXDgjv/nfMsZlLcAlah1cwAt07uLRqFwI4FsQbsBLtVg+S7NSGtw4pRo8EeqOWyb5f0+jly19jYyK5du+jfvz/9+/d33W42m7niiiuora3l008/JTg4uOcnOQf+l3Y334f7ytXq1av55S9/yRVXXMGzzz7rUUCfm5vL+++/z9tvv01jYyP19fX4+/vz0ksvcfnll7sK4cUPiwQsIX4gFEWhoqKCVatWkZ2dzebNmxk6dCiZmZlkZWWRkpLCJ598wltvvcUjjzxCXFycaxh1dXU1AQEBrpE93lYVbDY727eWsnaN5zDqxP7BDEozcqygzqOxaFfOrUN7l2Nq/QcYiIkJxFTRjN5X43Hq0JuoKH90Oo1rFW1gcgiRkQGUlXWGPV9fDYPSwti3t+du8ACTJsdhqmghMsqfUreBzu7ShwRz5HADNi8Lbs4Zg7FxjpFDvY0sCgnVExbm51FP5j5y6MSJesrLmhk5OopdXpqounOGWbVaxRUBsURqFfrTuQXZdQXruMVColsBebNic61aNWohyK1ULq9jTmGz3U6gVgUqiJ0VR8Zz03u9JqempiZ27txJQkICSUlJrtstFgtXX301JSUlbNy4kZCQkNN6vrOpp4bNv//977n77rsBx8pcZGSkq2Hz/8o9XO3cuZPdu3fz6KOPUldXxy9+8QueeOIJ/Pw86yAPHDjAvn37eOqpp9izZw9Dhgzh66+/9vrHkTj/ScAS4gdIURSqq6tZvXo12dnZbNy4kaioKMrKyrj11lt5+OGHPVa2LBYLVVVVVFRUUF1djZ+fn0fY6mkY9bo1+RQW1vPp+kIAYuMCSUw0UFPTypHDnVtgpzOQefiICBobzURHB/Y4sicuPhC7TaGsrNnLM0C/hGASE4LQaNVsOUUX94yMWLZ3qSfr2oV+yNBgcnMaug2GdpecEkplZQv1de0e8x3dm4oaw3wJMfh2a9fgTqtVMXFSHDarnfLyZtfMyW7X3WWlMNMWQYSvwrDAzlUokx9Eui2MnbCaSXBbwWpTbPh3/HLvOrew2hfC2xVOYsOgUxF3dTiM1hIaGkpkZCQRERE9tidobm5m586dxMfHM3DgQNftVquV6667jry8PD7//HOMRmOPn4ezrS9qWb+Phx56iKeffpoRI0bg5+fHwYMHOXHiBNdffz1PPvkkQUFBWCwWjxOWLS0tPPvss/zjH//goYce4sYbb5SWDT9AErCE+IFTFIVXXnmFO++8k6FDh5KTk0NiYiKLFi1i8eLFDBs2zKMGy2q1Ul1dTUVFBVVVVeh0OqKiooiMjCQ4ONjrD/E9uytYt8ZzGHVkpD9JA0MJCNCyaePxXpt6jh4TxcEDlZjNnUkmKjqApKQQ6uvbyM2pJiHRQEuzpVt9k7ugIB/i4h3F4zExAfQfEEJ9XRu5uZ3tE9znGPZm9NgQ2tusWK2Oeilv1z8ozcjJ0iYavay4xcUF0i/RQGuzmfr6doqKeu7zpdWqGD7Cczszvl8Q/foFe4RVb9uwl9giMfraGBbYuUV0zGYmSdMZqEqsFuLd2jLYsbt6X520WontKHi3Kwpm7Pip1eTrFa5ft5DwhGDXoQmTyUR9fT1BQUHdtpZbWlrYuXMnMTExJCcnu75ObDYbN910E/v27WPz5s0ecwfPB31Ry/q/+u9//8uCBQtYunQpt956K7GxsdTX13PDDTewZcsW5s2bx9NPP43BYHBtAzpXvqxWKxMnTsRgMHQ7xS1+GCRgCfED99RTT7lGF82YMYOGhgbWrVtHdnY269evJyoqyhW2Ro8e3a3JYXV1NSaTicrKSrRarWtly2AweA1bOYeqWPNRPuvW5GE0+vH19pMYw3xJSTHS2mrh0EHPkTtd5wF6M3JUJP7+PjQ2mnsc2RMSqic83Pusv/BwPwYmh9LSYsbf36fXtgcAQ4cFc+hggytUdb5/58ig9PQwjp/ofUZhRIQffv4+tLZYSRoY4vH+Tj4+KoYOi+x1/E9EpD+jRkdRdrKp2/v/zBaFwc/KsIDOgNV1uHMlNiLovF+F4mrt4B6+TlqtxPk4Htf/lnTG/nZkt2sxm80eW8v+/v6EhoZiMpmIjo4mNTXV9XVht9u57bbb+Prrr9myZYv0xuvgDElPPvkk9913H99++y1Dhw51rVS1tLRw00038c477/CrX/2Kv//97xiNRtf7OVer7r//ft544w22b99Ov379zvXLEt+RNBoV4gdMURROnDjBxo0bGTduHADBwcFcccUVXHHFFTQ3N/PJJ5+wYsUKFi5cSEhICIsWLSIzM5MJEyag0WhcKxV2u90Vtvbu3YtKpXKFrZCQEFcwSx8STvqQcJbeO5GjR2r4eG0Ba9fkuVaMDCF6Bg0yYjbb8PPTnnJkTdrgMAry61yrRAaDnkFpRswWOzkHHate4eF+BHoZteNUVdVKXV0bI0ZGcTi3hvETYjBb7OR2mc8IMGx4MAf2N3R7f2cxuiFEz7hx0dTXm7Faej4J6awVczYada68OV+/xWIj72gNySlhp5ytmJwS6tqGNYToSU01YrXYyMmpQtui6tbnqiu71Q4d8wWtKOjc3sH91Td3dGsHGDjb+y9snU5HXFwccXFxWK1WTp48SV5enqsGcM+ePQQGBnLRRRfxhz/8ga1bt0q4Ao8tvKqqKiIjI9FqtbS3t9Pe7jiV6uPjg81mw9/fnzfeeIO9e/fyn//8h9bWVp599lkiIiJcz1NdXc0XX3xBQEDAedPmQnw3soIlxE9Ea2srGzZsIDs7mzVr1uDr68uiRYvIyspi0qRJHiNM7HY7tbW1rm0jRVFcQcxoNHqsgjkdL6pn7Zp81q3JZ8/uCiZmxHHgQCVpg43YbQo5OVW0tXoGlqHDIjhWUEtLi/eGpQGBPoweHY1KDd/uKOvWBd6ppyHRAQE+DE4PQwFyD1UxMNm/W7jqatjwCPKO1tLWZiUgwIe09DAADudU0dzs+PjRMQFo1CpKS72fcHRe0/ARkdgVUKsg1+393fVWv+bvr+UqeyzBBivx5s737XpqsNJmJULT2fcqQO3WE0sHkR07nCasRKk1+AT5kLnzZ71+HsDRcmHnzp2EhYWRmppKbW0tzz//PP/85z9paWlBp9Px9NNP84tf/KJbwfZP1bPPPstDDz3Erl27yM/PZ+bMmfzxj3/kz3/+s2u7tb29Hb1ez6233sqaNWvw8fFh9uzZPPbYYxgMBhRFYe/evdx44408+OCDPXaiF+c3CVhC/ASZzWY2btxIdnY2q1evRqVSsWDBAhYvXszUqVM9Cm4VRaGuro6KigpMJhM2m42IiAiioqIwGo1ej4+Xljby8VrHfETnyUI/P0evKI1GTW5OFckpoeTmVNPe3vMqkXvRu6+vlvQhYd1G9vj6akgdFMb+fb2fKBw2Ipj2NjvBhkCOHq7pNp8RYMTISA7ner8mvV7T0VhVi8nUQt5R76tpjseqGZQW7nFNer1j4LPeV8PRIzXU1baf1uGAm3X9QNPCYN/Oz3MJVuLdNiDcWzE02u0Y3OZHOk8cmhWFAfcOZ8Iv09DoT7150d7ezs6dOwkNDWXw4MGu1RlFUbj33nt59913ycrKYtOmTZhMJi6++GLuuece15SInwr3laucnBwuueQSpk+fzt13301KSgo33ngjb7/9Ni+88AJXXHGFK4i2tLRw7bXXMnz4cIqLi/nPf/7Da6+9xs9+5gi+bW1t1NfXewzNFj8sMipHnHPOXk5d/3N2MZ4+fXq3+26++WaP5zhx4gTz58/H39+fyMhI7rnnHtf4CafNmzczevRo9Ho9ycnJvPnmm2frJZ53dDodc+fO5bXXXuPkyZP85z//QafTceONN5KUlMTNN9/M+vXraW9vR6VSERoaSlpaGhdccAGjRo1Cp9Nx+PBhtmzZwoEDB6ioqMDm1ucgLi6IG24ayaq1l7H34HU89vcLGTsuhv37Kvl2RxnpQ8JRqVSMGBmFweB9hEpiYjBms911otB9ZE9bm43hIyOZOCmWIcPCTxmuhgwL4sC+Bo4eaWLnjnJaW60MGx7hMTJo1OgocnOqegx87e02Kiubyc+vo/BYPcOGRTAhI5bwLiOHfH01DPIS+Nrbbezba2LH12U0NpiZdVEiil0hKqrn7Z/hIyKwtNm7jUuxWz3fdv9BbusymdCnY4PRP8afSb8eetrhateuXRgMhm7hatmyZSxfvpzt27fz2muvUVBQwNatWxk2bFi377mfAufnZv/+/VRUVODv789tt91GSkoKAHfffTczZ87k1ltv5bHHHmPv3r3U1NTw9ttv8+WXXzJ48GBefPFFIiMjeeutt1zP6+vrK+HqB05WsMQ5V1lZ6fHL+eDBg1x00UV8/vnnTJ8+nenTp5OamsqDDz7oeoy/v7+riaHNZmPkyJFER0fzxBNPUFZWxtVXX80NN9zAww8/DDhmjg0dOpSbb76Z66+/no0bN3LXXXexbt065syZc3Zf8HnMZrPx1VdfsXz5clatWkVjYyNz584lKyuLWbNmeWwDKYpCY2Oja2Wrra2N8PBwoqKiCA8P99hydKqpaWXjhiI+Wp3Pls+PYzbb0WrVpKeH4R/gQ16eowv7wOQQamvaqPEyPscpKMiHuLgg8vJqGZweRmCgjoJ8z5E9AOlDA8k52PNWnlqt4sKZCbS2WCnIr3U1Fu2qX78g2tttmEye96tUjjqykBA9J082ERSk5+CByh4/HnieFnT22goL8/Pooj98RASHD9dwTUs0msBWBvt2fj6LrRb6uZ0abEPBtyNIVdtsRGgdkatdUdAAWpWKmAtjmfLqtF6vCxyrmzt37iQoKIihQ4d6HHR45JFHePXVV9myZQtpaWmnfK6fivz8fFJTUzEaja5xN+5yc3P5xz/+weuvv45Op0Ov19PU1MSiRYtYuXIlALNmzaK0tJQDBw54/d4RPzwSsMR556677mLt2rXk5eWhUqmYPn06I0eO5Omnn/b6+E8++YQFCxZw8uRJ1198L7/8MkuXLqWyshKdTsfSpUtZt24dBw8edL3f5ZdfTl1dHevXrz8bL+sHx2638/XXX7vCVmVlJXPmzCErK4vZs2d7NCtVFIWmpibXfMTW1laMRiNRUVFERER4bDk6NTS0s+G/haz9KJ/Nn5+gtdWKWq1iytR4FDscPVLdY9gJCdETHtH9RKF72Ckqqic0VEXOoZ7DFTi6z+/ZVeE6uZc6qHvY6WlEjjs/fy1JSSG0tVmJjAzg5Mkmjhd173U1aVKc16HUTgOSDAwcGErxiQaOHKnhFls8qsAWBrkFrFKrhTi3gGVWFHQdQahGbSdccfz/E3YrCWrH+018ahL9FiTSG4vFws6dOwkICGDo0KEetXZ///vfefbZZ10NbkWn6upq3njjDZ5//nkqKipYs2YNM2fO7FaruH79erZu3YrZbGbAgAGulficnBwuv/xykpOTef/999FqtdLz6kdAApY4r5jNZmJjY/nd737Hn/70J8CxRXjo0CEURSE6OpqFCxfyl7/8xXWy5v777+ejjz5i7969rucpLCwkKSmJ3bt3M2rUKKZOncro0aM9Qtq//vUv7rrrLurrvTd8FJ3sdju7du0iOzubFStWUFJSwkUXXURmZibz5s3rNhKlubnZtbLV1NSE0Wh0FcnrdLpuz9/cbGHjZ0V88fkJPv1vISZTCyqVI+wYw/w4XlTPyY6C8rBwPwzB+l6beqrVMCgtkKYmO/HxIZSWNHUb2QMwfkIMO78t79Z93mlAkoH+/YOpqm7jwL6eV6X8/bX0H9B9KHVnY9MW8vNqTxmuoHPlytxuIz4+iJ+VGtEaW4l3Ow5YhY1wt7YMdkVB3fELucxmJa7jRGHAlQMYc/EAbM0WoqfHotb0XBVisVjYtWsXfn5+3XqnPffcczz22GNs2rTJY6SM6GQymVwzW8eNG8drr73mMQC7J4cPH+af//wnzz33HNnZ2SxcuPAsXK04G2QdUpxXVq1aRV1dHb/61a9ct/3iF78gMTGR2NhY9u/fz9KlSzly5AgrVqwAoLy8vFutgvPt8vLyXh/T0NBAa2urnIA6BbVazbhx4xg3bhwPP/wwBw4cYPny5Tz55JPceuutzJw5k0WLFrFgwQJCQkIICAggKSmJpKQkWlpaMJlMnDx5ksOHD7s6hkdGRqLXO+qvAgJ8WJSZwqLMFNrarGz5/ARrPspnw38LXU04k1NCiY0NoLnZwq6dPbc90GhgYHIAuTmOQFZ8omOWYH8DMXGBmMqbKSioY8LEGHZ8U9ZrCwm1SsXePZXU1rbRr18Q8f2Cu3WhDwjQktjf0C1cAZw43uBq4zBtej/azTYGp4dx2K0xqjv3cAVQUtKI3RZKW6sF9J0rVhqVCmeplU1RHG93aHe2YlDB9BuH4x976iP+FouF3bt3o9fru4WrV155hUceeYTPPvtMwhWdPa6am5tpaWlBpVIRHh5OZGQkl19+OSqViqVLl3LTTTfxz3/+k/j4eKCzGN69KP7999/nwQcf5OTJkzz//PMSrn5kJGCJ88rrr7/O3LlziY2Ndd124403uv7/sGHDiImJYebMmRQUFHiM6xBnh1qtZsSIEYwYMYIHH3yQ3Nxcli9fzksvvcQdd9zBtGnTyMrKYsGCBYSHh+Pv7+8aCtzW1obJZKK8vJwjR45gMBhcvbacY0l8fbXMmZvEnLlJrmHU69YUsGtnOQX5dZSWNrnCUteRNVqtigFJfhw90n3UTlFRPUUdW3bTZyTQ3mYjJdXodWQPQHJKCJWVrdTXOXoYFRc3urYMo6IDGDDAQHOzBavVTs6hnmcUgqPmyn20T1i4H8nJobS2OhqTWq1Kt3DlpEEFXbeL7ArO5lhWwP0cp/OhOoPutMKV1Wplz549+Pj4MGLECI9w9cYbb/DXv/6VTz/9lLFjx57yuX7snOFq69at/N///R/79+8nMDCQlJQUXnjhBfr3789VV12Fj48Pv//977n22mt5/fXXSUhIcIUq5/9arVYiIiKYPHkyc+fOZfHixefypYkzQAKWOG8cP36czz77zLUy1RPnMfD8/HwGDhxIdHQ0O3bs8HhMRYVjhcPZ/DA6Otp1m/tjgoODZfXqe1CpVKSnp3P//ffzl7/8hfz8fJYvX86bb77JXXfdxeTJk8nKymLRokWuEJWQkEBCQgLt7e2uPlt5eXkEBQW5RvY4t399fDTMmNmfGTP7dxtG7Wxv4Bg5E0RVVTOKYiHvaM91UgAZk2LZvOmE6+2oKH/HyJ6GdnJzHCtLKamhmCpaqK9v9/ocFeXNtDSbiY0LorKyhQkTYz3CkufH6z7+prqqlWpnY1ODnnETYqirbUPdtexGAS0qui52qRRcActxatDxRjsK/Ttqs6IuiOn18wCOQw179uxBo9F0C1dvv/029957Lx9//DETJ0485XP9FKjVar755htmz57NqFGjuOqqq2htbeWjjz5izJgxrF+/nnHjxnH55Zej0Wi45557uPbaa3nllVdITk72eC6tVsuMGTOYNGlSn8w8FOcfqcES540HHniAV155heLi4l5P0WzdupUpU6awb98+hg8f7ipyLysrIzIyEoBXX32Ve+65B5PJhF6vZ+nSpXz88cccOHDA9Ty/+MUvqKmpkSL3M0BRFIqKisjOzmblypV88803TJw4kczMTDIzM4mLi/Mo4nWOZ6moqKCmpobAwEDXypazOaM7u13h2x1lHfMRC6iqbCY2Tk9jo53klDAa6to95hM6narvVFi4HyNHRlJf386e3RU9jvcJDtYRHRPYbfXL2YXeYrGTm1PFqNFRbN/W+0xE95Urf38tg9PDUakdjVHbmmzcbU9EFdZIrKpznarJbiewIwzV220Y1I77VCmBzHhoArU5NcTOjCMgNtDrx4TOcAWOIcju/czef/997rjjDj766CNmzJjR6/X/lNTX17Nw4UICAwN5/PHHXcX+M2bMYPfu3axatYpp06ahUqloampi5cqVXHPNNdx44428/PLL5/jqxdkmAUucF+x2OwMGDOCKK67g0Ucfdd1eUFDAu+++y7x58wgLC2P//v389re/JT4+ni1btgCdbRpiY2N5/PHHKS8v56qrruL666/v1qbhtttu47rrrmPTpk385je/kTYNZ4GiKJSWlrJixQqys7PZtm0bo0ePJisri8zMTBITEz3ClsVi8ZiF5+fn51rZCgwM7Ha6qrGxkQ8/+JKcgwpffVlFUaFjGzA83I/klFCaGs3k5FQxMSOObado6pk2OIziYsf8QW8je8ARrqKiA3ptNAow+YJ42lqtoHKEJW/d6nvaFgRHY9JhqWHM2OuPPqqFcLeHtCl2fFWOgFVtsxHWEY6G3T2M9FuG9Hpd4Pie2bt3L3a7ndGjR3uEq5UrV3LTTTexYsUKZs+efcrn+imprKxkxIgR/OlPf+L2228H4Nprr2XFihW88847zJw5Ez8/P9fg5vr6erZv387MmTO9nqQVP24SsMR54dNPP2XOnDkcOXLEY4p9cXExv/zlLzl48CDNzc3069ePxYsXc99993mcXDt+/Di33HILmzdvJiAggGuuuYZHH33UYyVs8+bN/Pa3vyUnJ4f4+Hj+8pe/eBTTizNPURTKy8tZtWoV2dnZbNmyhWHDhpGZmUlWVhbJyckeAcpqtVJVVUVFRQVVVVX4+vq6VraCgoJoaGhgz549JCYmMmDAAAAOHaxk7RpHF3nnCtMF0/rR3malvd1GzqFKLJbuP/bSh4RxvKiB5ubuw50DAn0YPDgMlcpx4vF0aq7ctwUdXeDD0Ok0HDlcQ319e6/hyinO6M+VlZFoQhqJ1naGIKuioO34PBVYzQzU6kAFlx287JSNRO12O3v37sVqtTJ69GiP75G1a9dy7bXX8sEHHzB//vxen+enKD8/n/T0dFatWsW8efO44YYb+M9//sNbb73FggUL0Ol0VFRU8Pvf/57nnnuOkJAQ1/s6Q5f46ZCAJYQ4JxRFobq6mtWrV7N8+XI2bdrEoEGDXPMR3TuIg+MXVFVVFSaTicrKSjQaDRaLhfj4eAYNGuS1b1De0Rq+2HyC/7ybw8EDjlN+QUE60gaHYbPaHfMR22wMGRrOsYI6Wlt77kQeEqonLMyP0pIm18ieI15G7mRkxLJ9e8/bglqtmqnT+9HaYuXo0RpXLVZXYeF+RPjqWXQ8BF1IIxHaHn4569XQbickzcCctb3PrLPb7ezbtw+z2czo0aM9VlXWr1/PVVddxdtvv80ll1zS6/P8FDmHoV9wwQXMmDEDi8XCO++8w7/+9S8yMzPx9fXFbrfzt7/9jffff58PPviA9PT0c33Z4hySgCWEOOec8w4/+ugjsrOz2bBhA4mJiWRmZrJ48eJuTS9PnDhBXl4egYGBtLS0oNFoXK0fQkNDvYatrsOoFcXRv2rS5Diamizs32fqceh0qNGX0BDfbr23fHzUpA8Jx9dXy9GjNQwaZOTrXsIVeG4LqtUq0gYbMRj0FBbWU94xFsgY5ktwkJ66wmZutMfjF9qIsWP1w331SgnUMm/lRZi+NhE62EjYyLAeP67dbufAgQO0trYyZswYj3C1ceNGrrjiCl5//XWWLFnS6/X/FLivNrm3VQBYtmwZy5YtA+CFF17glltucT3uiy++4He/+x2DBg3izTff9NrzTfx0SMASQpx3GhoaWLt2LdnZ2axfv57o6GjXNmJxcTG3334769evZ9iwYdjtdmpra12NTVUqlWsYdWhoaLdu2gAnSxtZt7aAb3eUseG/hbS2WtH7akhPD0erVXPkcLVrZcoY5usIQMd6b0ibMSmOxsb2Hkf2QO81V+A4vRgdHUBrq5Wd35YTpvjwa3scgaGNGDp+4bvXX8XOjOWCV6ae8vNpt9td2+xjxozx+MX/xRdfcNlll/Hyyy/zy1/+8pTP9WPnDFdlZWU8+eSTlJeXM336dGbPnu1qHHrbbbe52pJceeWVjBs3jrfffpuXXnoJk8nEN998Q3h4eLdwJn5aJGAJIc5rTU1NfPLJJ6xYsYLVq1fT1tbGBRdcwP3338/48eM96lrsdjt1dXWukT2KohAREUFkZCRhYWFew5apoplPPj7GujX5bNtaitVqd61MBfj7UN/QzqGD3ZuIupuYEeuxcqVSwaC0MEJD9RQVNVB2sum0aq5CQvWEhvpSeKye/v0NJAcHMnqPDwZjk+vUoPscwjkfX0xIakiv16YoCgcPHqSxsZGxY8d6hKtt27axePFinnnmGa677rpen+enxGQyMXbsWOrr6/Hz86OqqopZs2Zx7733Mm3aNOrq6njggQd49tlnUalUaDQaAgICSE5OZtWqVcTFxUnNlZCAJYT4YVi1ahVXXnklt956KxUVFaxduxY/Pz8WLVpEZmYmkyZN8ijYVhSF+vp618qW1Wp1DaMOCwvz+suvpqaV9Z8cY92aAnJzqtBq1ZSWNLqGSefn1VLVpWaqa7jyZtqF/bBaFEqKGzh+vPvIHnCEK2Oon8c2ZKyi55f2GMLDm9F39LqyB2hQN9vQh+vJ+rr35pSKopCTk0N9fT1jxoxxdc4H+Pbbb1m0aBGPPfaYaybeT5nVakWr1WK323n88cdZu3Ytjz76KKmpqezcuZMlS5YwcOBAHnvsMdfJ4w0bNnD8+HHKysoYP34848aNw2g0SrgSgAQsIcQPgDNcvfvuu2RmZgLQ3t7Oxo0byc7OZvXq1Wg0GhYsWMDixYu54IILPGqMFEWhoaHBtbJlNptd403Cw8O99l1rbGjn0y7DqN2HSRcW1pPY38A336HmCjpG9sQGYjI1U5BfBziGVxvD/Dy60gP0U3y5wh5NZFgzPioVilbF4m+yKNtchm+YL9FTonv8uIqikJubS21tLWPHjvUIV3v27GHBggUsW7aM3/zmN71e/49ZUVEROp3ONTmisbGRjz/+mPfee4+EhASefvpp1xbfoUOHmDJlCrGxsTzyyCMsWrTI63M6u70LIQFLCHHey8vL49ixYz32LLNYLGzZsoXly5ezatUqLBYL8+fPZ/HixUyfPt0jXCiKQlNTk2tlq7W1lbCwMKKioggPD/far8g5jHrdmnw++7SI5mYLEybGUlPTSni4PyXFDa4xOu5OtS0YHx/EgCQDdgW2flnS7f7+ii8/t0cRF97R9T0thIvXXnzKz5eiKBw+fJjq6mrGjh3r0Sl8//79zJs3jz/96U/8/ve/P+Vz/Vjt3bvXNQD+tttuQ6PRcMstt/DKK6+QlJTEI488ws9+9jNsNhuKoqDVajl8+DBTpkwhIiKCxx57rMeQJQRIwBJC/MjYbDa+/PJLV9hqampi3rx5ZGVluRpBumtqanKtbDU3NxMWFkZkZCQRERFeT4G1tVnZ9lUJK7KPsuG/ha5xOklJIUTFBFB2spGiwobTqrkyGPSER/hRkF9HVHQASQMMHiN7khU/ZqtCGRTqON046fnJ9Lu4X6+vX1EUjh496qojcn+9OTk5zJ07l9/+9rf86U9/Ou3P6Y9NTk4OkydPJiMjgyeeeIIhQxzNWevr67nlllt47733mDlzJm+++SZxcXFA5xbisWPHmDZtGm1tbbzxxhsyoFn0SNYxhTjDHnjgAVQqlcd/aWlprvvb2tq47bbbCAsLIzAwkEsvvbTb3MQTJ04wf/58/P39iYyM5J577sFq9WwpsHnzZkaPHo1eryc5OZk333zzbLy8845Go2H69Ok8//zzHD9+nHXr1hEdHc3SpUvp378/11xzDStWrKC52dESITAwkKSkJDIyMpg0aRIhISGUlJTwxRdfsGvXLkpKSmhv75xJ6OurZcas/jz/0mwOHrmedz9YxJVXDaGuvo3tW0spKmzggqnxBAXpSEgI6vE6DQY9EZH+rm3CivJmtm8/Sc6hakKNvkyYGENKvxD6xTp+TGv8NKcVrvLy8qioqGDMmDEe4ero0aMsWLCAW2+99ZyHq1N9T5xJeXl5TJ48mfHjx/P3v//dFa4ADAYD//73v7n88svZtGkTr732mut7UavVYrFYSEpK4quvvsJgMHSbLyiEO1nBEuIMe+CBB1i+fDmfffaZ6zatVkt4eDgAt9xyC+vWrePNN9/EYDBw++23o1ar2bp1K9A5Cig6OponnniCsrIyrr76am644YZuo4Buvvlmrr/+ejZu3Mhdd90lo4Dc2O12du7c6ZqPWFpaykUXXURmZiZz5871mAwA0Nra6lrZamhowGAwuEb2eBvO6xxGvXFjEWtW51PSsWUYGxdIYqKB2tpWDuc6OssHB+uIjAogP6/3cTsPxiTw89UzaCpoADXEz4rv8bGKopCfn09ZWRljx451DcwGx8ipiy++mKuvvpqHH374nLcOONX3xJlSVFTEhAkTGDp0KM8884xrliDAV199xSeffMLf/vY32trauPbaa1m+fDn33XcfN910k2twvMViwcfHx6MoXmquhDcSsIQ4wx544AFWrVrF3r17u91XX19PREQE7777LpdddhkAhw8fZvDgwWzfvp2JEye6hlmfPHmSqKgoAF5++WWWLl1KZWUlOp2OpUuXsm7dOg4ePOh67ssvv5y6ujoZZu2F3W5n//79LF++nBUrVnDs2DFmzpxJZmYm8+fPJyQkxCOEtLW1YTKZMJlM1NXVERwc7BrZ03XL0fH8bsOo1+RTWtoEQGSkPymDjGg0Kr76ohi7vedrXDY5mfAqO5duW3Bar6mgoICSkhLGjh3rMSD7+PHjzJ49m5/97Gc8+eST5zxcQe/fE2dKXV0daWlp+Pn5sWrVKkaMGOG6b9euXcyYMYOMjAw++OADgoODMZvN/PrXv+bdd9/lT3/6E7fccourGB66NyAVoiuJ3UKcBXl5ecTGxpKUlMSVV17JiRMnAMcPdovFwqxZs1yPTUtLIyEhge3btwOwfft2hg0b5gpXAHPmzKGhoYFDhw65HuP+HM7HOJ9DeFKr1YwcOZKHHnqIQ4cOsWvXLsaPH8+LL77IgAEDWLx4MW+++SZVVVUoioKvry8JCQmMHTuWqVOnEhsbS01NDVu3buXrr7+msLDQteXoeH4VEybG8uDfprJz37V8/OnPue2OMYRH+GGqaOaLzcWEhPoyYWIsw0dEoNV6/qL+68xUQnIaSL065bRez7FjxyguLmbMmDEe4aqkpIS5c+eSmZl53oQrp56+J86UyspK0tLSqKqqIicnx3X7/v37mT17NjNnzuT11193rWTqdDr+9a9/cc011/D444/z+OOPU1LSeRDhfPpcivNT71NBhRDf24QJE3jzzTcZNGgQZWVlLFu2jAsuuICDBw9SXl6OTqfzGAoLEBUVRXl5OQDl5eUe4cp5v/O+3h7T0NBAa2ur11UW4aBSqRgyZAhDhgzh/vvvJy8vj+XLl/Ovf/2LO++8kylTppCVlcXChQuJiopCp9MRHx9PfHw8FouFyspKKioqKCgoICAgwLWyFRAQ4KovGj0mmtFjovnLA5M9hlF/87WjxYPBoCd1kBGr1c4CowHjrjrw0TLkhlMHrKKiIk6cOMGYMWMIDAx03V5WVsa8efOYPXu2qyHm+aK374mgoJ7r1r6PlJQUXn31VX7zm99w/fXXo9PpSEtLY9asWWRkZPD000+7Ctqd235arZZXX30VlUrFs88+y+23335Grk38OEnAEuIMmzu3cwDv8OHDmTBhAomJiXzwwQcSfM4zKpWK1NRU/vSnP3HvvfdSWFhIdnY277//PnfffTcZGRlkZmayaNEi4uLi8PHxITY2ltjYWKxWK5WVlZhMJoqKivD19XXVbAUFBbkCzpChEQwZGsHSeydy9EgN69bk8/E6x9ie32QMxryhhchrB5E4NRy1pvdNhuPHj1NYWMiYMWM8gklFRQXz58/nggsu4OWXXz7vaoR6+5749a9/fcY+bmpqKs8//zx33nknv/jFL9BqtUydOpUXX3zRNQZHURTX58tkMlFeXs4zzzzDH/7wBylqF9/J+fVdJ8RPQEhICKmpqeTn5xMdHY3ZbKaurs7jMRUVFa6i2ujo6G6nCp1vn+oxwcHBEuL+RyqViqSkJO655x62bt1KYWEhl112GWvWrCE9PZ2ZM2fyzDPPUFRU5OqTFBMTw4gRI5g+fTrJycm0tLSwc+dOtm7dytGjR6mvr8e97DV1kJHf/n48Gz6/gl17fkXWVWmMumkgqZclkJTZ+4nB4uJijh07xujRoz0K9CsrK1mwYAFjxozhtddeO+/ClTfu3xNnWnJyMs8//zxLliyhtbWVKVOmuFau3OuqysrKuP/++7nyyiupra1l0KBBZ/zaxI/L+f+dJ8SPTFNTEwUFBcTExDBmzBh8fHzYuHGj6/4jR45w4sQJMjIyAMjIyODAgQOYTCbXYzZs2EBwcDDp6emux7g/h/MxzucQ349KpaJfv37ceeedbN68meLiYq6++mo+++wzRowYwdSpU/n73/9OXl4eiqKg0WiIiopi+PDhTJs2jdTUVMxmM7t37+arr77iyJEj1NbWeoStuIRg0pf0Y/ojQ4nLCOv1ekpKSsjPz2fUqFEYDAbX7TU1NSxatIghQ4bw73//+wczrsX9e+JsGDBgAMuWLePSSy9l2bJl/POf/8RsNrvCVXl5OU899RSvvvoqd955J/369R52hfBKEUKcUXfffbeyefNmpbCwUNm6dasya9YsJTw8XDGZTIqiKMrNN9+sJCQkKJs2bVJ27typZGRkKBkZGa73t1qtytChQ5XZs2cre/fuVdavX69EREQo9957r+sxx44dU/z9/ZV77rlHyc3NVV544QVFo9Eo69evP+uv96fEbrcrJpNJefXVV5U5c+YoOp1OGTZsmHLfffcpO3fuVJqampTm5mbXf42Njcrx48eVHTt2KOvWrVM+/vhjZefOncqJEyeUxsZGj8f29N/Ro0eVNWvWKKWlpR63l5aWKqNGjVIyMzMVs9l8rj81vTrV98TZUlxcrCxZskTRaDTKM888oyiKophMJuXee+9VVCqV8vrrr7sea7fbz+q1iR8+CVhCnGFLlixRYmJiFJ1Op8TFxSlLlixR8vPzXfe3trYqt956qxIaGqr4+/srixcvVsrKyjyeo6ioSJk7d67i5+enhIeHK3fffbdisVg8HvP5558rI0eOVHQ6nZKUlKT861//OhsvT3Sw2+1KdXW18q9//UtZuHCh4uvrq6SlpSlLly5Vvv76624BqrGxUTlx4oSyc+dO5eOPP1bWrVun7NixQzl+/HiPYSsvL09Zs2aNUlxc7HF7eXm5Mn78eGXevHlKW1vbuf5UnNKpvifOptLSUuXKK69U1Gq1smzZMuW+++5TVCqV8uKLL7oeI+FK/C+kD5YQQpwB9fX1rF27lhUrVrB+/XpiYmLIzMwkKyuLUaNGedRGKYpCXV2daz6izWYjIiKCyMhIwsLC0Gg0lJeXk5OTw4gRIwgL69xCbG5uJisrC39/f9asWeO1CaroXXl5Offddx9vvPEGAE8//bRrCLYi/a7E/0gClhBCnGFNTU18/PHHrFixgo8//hij0ciiRYvIyspi3LhxHrVSiqJQX1/vamxqNpsJDAyksbGRoUOHerTjaGlp4bLLLkOtVrN27VqP7u3iu6moqOC+++5jzJgx3HzzzQDSpV18LxKwhBDiLGppaeHTTz8lOzubtWvXEhAQwMKFC8nKyiIjIwOttrN7jqIoFBUVkZ+fj16vx2KxsHv3bgwGAwsXLuTmm2+mra2NTz75xKMHlvjfuPeMk3Alvi8JWEIIcY60tbWxceNGsrOz+eijj9BoNCxcuJDFixczZcoUsrOzeeGFF1i+fDmRkZE0Nzfz/PPP8/bbb3P8+HEMBgOPPPIIS5YsITQ09Fy/HCGEGwlYQghxHrBYLGzevJnly5ezevVqWlpaaGlp4aabbuJvf/sbOp3O9birrrqK/Px8LrvsMtatW8eBAweYMWMG9913H1OmTDnHr0QIARKwhBDivPPpp5+SmZnJlClTyM3Npampifnz57NgwQI++OADCgsL2bRpE0ajEcDVcX7q1KmMHz/+HF+9EAIkYAkhxHlly5YtLFiwgBdffJGrrroKm83G9u3byc7O5q233sJisVBQUEBERMS5vlQhRC8kYAkhxHnkueeeIyAggOuuu67bfRaLheLiYpKSks7BlQkhvgsJWEL0gRdffJHbbruN8ePH880335zryxFCCHGOyRlUIfrAO++8Q//+/dmxY8dZGVh7PnrkkUcYN24cQUFBREZGkpWVxZEjRzweM336dFQqlcd/zp5DTidOnGD+/Pn4+/sTGRnJPffcg9Vq9XjM5s2bGT16NHq9nuTkZN58880z/fKEEOI7kYAlxPdUWFjItm3b+Mc//kFERATvvPPOub6kc2LLli3cdtttfP3112zYsAGLxcLs2bNpbm72eNwNN9xAWVmZ67/HH3/cdZ/NZmP+/PmYzWa2bdvGv//9b958803uv/9+12MKCwuZP38+F154IXv37uWuu+7i+uuv57///e9Ze61CCHFKZ3MujxA/Rv/3f/+nhIaGKu3t7cott9yipKSkdHtMVVWV8stf/lIJCgpSDAaDcvXVVyt79+5VgG4zA3Nzc5VLL71UCQ0NVfR6vTJmzBhl9erVZ+nV9B2TyaQAypYtW1y3TZs2Tbnzzjt7fJ+PP/5YUavVSnl5ueu2l156SQkODlba29sVRVGUP/zhD8qQIUM83m/JkiXKnDlz+vYFCCHE9yArWEJ8T++88w6XXHIJOp2OK664gry8PL799lvX/Xa7nYULF/Kf//yHa665hr/97W+UlZVxzTXXdHuuQ4cOMXHiRHJzc/njH//Ik08+SUBAAFlZWaxcufJsvqzvrb6+HsDVSsDpnXfeITw8nKFDh3LvvffS0tLium/79u0MGzbMYxzMnDlzaGho4NChQ67HzJo1y+M558yZw/bt28/USxFCiO9Me+qHCCF6smvXLg4fPsxzzz0HwJQpU4iPj+edd95h3LhxAKxatYrt27fz9NNPc+eddwJwyy23cNFFF3V7vjvvvJOEhAS+/fZb9Ho9ALfeeitTpkxh6dKlLF68+Cy9su/Hbrdz1113MXnyZIYOHeq6/Re/+AWJiYnExsayf/9+li5dypEjR1ixYgXgGLrrHq4A19vl5eW9PqahocFj1IkQQpxLsoIlxPfwzjvvEBUVxYUXXgiASqViyZIlvPfee9hsNgDWr1+Pj48PN9xwg+v91Go1t912m8dz1dTUsGnTJn7+85/T2NhIVVUVVVVVVFdXM2fOHPLy8igtLT17L+57uO222zh48CDvvfeex+033ngjc+bMYdiwYVx55ZW89dZbrFy5koKCgnN0pUIIcWZIwBLif2Sz2Xjvvfe48MILKSwsJD8/n/z8fCZMmEBFRQUbN24E4Pjx48TExODv7+/x/snJyR5v5+fnoygKf/nLX4iIiPD4769//SsAJpPp7Ly47+H2229n7dq1fP7558THx/f62AkTJgC4Tl5GR0dTUVHh8Rjn29HR0b0+Jjg4WFavhBDnDdkiFOJ/tGnTJsrKynjvvfe6rdSAY3Vr9uzZp/18drsdgN///vfMmTPH62O6hrLziaIo3HHHHaxcuZLNmzczYMCAU77P3r17AYiJiQEgIyODv/3tb5hMJiIjIwHYsGEDwcHBpKenux7z8ccfezzPhg0byMjI6MNXI4QQ348ELCH+R++88w6RkZG88MIL3e5bsWIFK1eu5OWXXyYxMZHPP/+clpYWj1Wsrv2ynN25fXx8uhVx/xDcdtttvPvuu6xevZqgoCBXzZTBYMDPz4+CggLeffdd5s2bR1hYGPv37+e3v/0tU6dOZfjw4QDMnj2b9PR0rrrqKh5//HHKy8u57777uO2221w1aTfffDPPP/88f/jDH7juuuvYtGkTH3zwAevWrTtnr10IIbo518cYhfghamlpUYKCgpTrrrvO6/1bt25VAOW9995Tli9frgDK008/7brfZrMpM2bM6NamYfr06YrRaFROnjzZ7TlNJlOfv46+BHj9z/n6Tpw4oUydOlUxGo2KXq9XkpOTlXvuuUepr6/3eJ6ioiJl7ty5ip+fnxIeHq7cfffdisVi8XjM559/rowcOVLR6XRKUlJSt1YXQghxrsmoHCH+B++//z6XX345q1atIjMzs9v9drud6OhoJk6cyMqVK5k0aRK7du3illtuIS0tjY8++giTycTevXt58803XS0bcnJymDJlCmq1mhtuuIGkpCQqKirYvn07JSUl7Nu372y/VCGEEP8D2SIU4n/wzjvv4Ovr67XVAjhOCc6fP5933nmHuro61q1bx5133sm///1v1Go1ixcv5q9//SuTJ0/G19fX9X7p6ens3LmTZcuW8eabb1JdXU1kZCSjRo3y6GYuhBDi/CYrWEKcI6tWrWLx4sV89dVXTJ48+VxfjhBCiD4kAUuIs6BrA0ybzcbs2bPZuXMn5eXl0l5ACCF+ZGSLUIiz4I477qC1tZWMjAza29tZsWIF27Zt4+GHH5ZwJc6ZF154gSeeeILy8nJGjBjBc889x/jx48/1ZQnxoyArWEKcBe+++y5PPvkk+fn5tLW1kZyczC233MLtt99+ri9N/ES9//77XH311bz88stMmDCBp59+mg8//JAjR464epAJIf53ErCEEOInaMKECYwbN47nn38ecJx87devH3fccQd//OMfz/HVCfHDJ6NyhBDiJ8ZsNrNr1y6PhrZqtZpZs2axffv2c3hlQvx4SMASQoifmKqqKmw2G1FRUR63R0VFuTrwCyG+HwlYQgghhBB9TAKWEEKcJS+88AL9+/fH19eXCRMmsGPHjnNyHeHh4Wg0GioqKjxur6ioIDo6+pxckxA/NhKwhBDiLHj//ff53e9+x1//+ld2797NiBEjmDNnDiaT6axfi06nY8yYMWzcuNF1m91uZ+PGjWRkZJz16xHix0hOEQohxFlwvp3ae//997nmmmt45ZVXGD9+PE8//TQffPABhw8f7labJYT47qTRqBBCnGHOU3v33nuv67ZzfWpvyZIlVFZWcv/991NeXs7IkSNZv369hCsh+ogELCGEOMN6O7V3+PDhc3RVcPvtt0uzWyHOEKnBEkIIIYToYxKwhBDiDJNTe0L89EjAEkKIM0xO7Qnx0yM1WEIIcRb87ne/45prrmHs2LGuU3vNzc1ce+215/rShBBngAQsIYQ4C+TUnhA/LdIHSwghhBCij0kNlhBCCCFEH5OAJYQQQgjRxyRgCSGEEEL0MQlYQgghhBB9TAKWEEIIIUQfk4AlhBBCCNHHJGAJIYQQQvQxCVhCCCGEEH1MApYQQgghRB+TgCWEEEII0cckYAkhhBBC9DEJWEIIIYQQfUwClhBCCCFEH5OAJYQQQgjRxyRgCSGEEEL0MQlYQgghhBB9TAKWEEIIIUQfk4AlhBBCCNHHJGAJIYQQQvQxCVhCCCGEEH1MApYQQgghRB+TgCWEEEII0cckYAkhhBBC9DEJWEIIIYQQfUwClhBCCCFEH5OAJYQQQgjRxyRgCSGEEEL0MQlYQgghhBB9TAKWEEIIIUQfk4AlhBBCCNHHJGAJIYQQQvQxCVhCCCGEEH1MApYQQgghRB+TgCWEEEII0cckYAkhhBBC9DEJWEIIIYQQfUwClhBCCCFEH5OAJYQQQgjRxyRgCSGEEEL0MQlYQgghhBB9TAKWEEIIIUQfk4AlhBBCCNHHJGAJIYQQQvQxCVhCCCGEEH1MApYQQgghRB+TgCWEEEII0cckYAkhhBBC9DEJWEIIIYQQfUwClhBCCCFEH5OAJYQQQgjRxyRgCSGEEEL0MQlYQgghhBB9TAKWEEIIIUQfk4AlhBBCCNHHJGAJIYQQQvQxCVhCCCGEEH1MApYQQgghRB+TgCWEEEII0cckYAkhhBBC9DEJWEIIIYQQfUwClhBCCCFEH5OAJYQQQgjRxyRgCSGEEEL0MQlYQgghhBB9TAKWEEIIIUQfk4AlhBBCCNHHJGAJIYQQQvQxCVhCCCGEEH1MApYQQgghRB+TgCWEEEII0cckYAkhhBBC9DEJWEIIIYQQfUwClhBCCCFEH5OAJYQQQgjRxyRgCSGEEEL0MQlYQgghhBB9TAKWEEIIIUQfk4AlhBBCCNHHJGAJIYQQQvQxCVhCCCGEEH1MApYQQgghRB+TgCWEEEII0cckYAkhhBBC9DEJWEIIIYQQfUwClhBCCCFEH5OAJYQQQgjRxyRgCSGEEEL0MQlYQgghhBB9TAKWEEIIIUQfk4AlhBBCCNHHJGAJIYQQQvQxCVhCCCGEEH1MApYQQgghRB+TgCWEEEII0cckYAkhhBBC9DEJWEIIIYQQfUwClhBCCCFEH5OAJYQQQgjRxyRgCSGEEEL0MQlYQgghhBB9TAKWEEIIIUQfk4AlhBBCCNHHJGAJIYQQQvQxCVhCCCGEEH1MApYQQgghRB+TgCWEEEII0cckYAkhhBBC9DEJWEIIIYQQfUwClhBCCCFEH5OAJYQQQgjRxyRgCSGEEEL0MQlYQgghhBB9TAKWEEIIIUQfk4AlhBBCCNHHJGAJIYQQQvQxCVhCCCGEEH1MApYQQgghRB+TgCWEEEII0cckYAkhhBBC9DEJWEIIIYQQfUwClhBCCCFEH5OAJYQQQgjRxyRgCSGEEEL0MQlYQgghhBB9TAKWEEIIIUQf+/8uUaOpUzZfygAAAABJRU5ErkJggg==' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -330,7 +330,7 @@
     "make_hazard_widget(\n",
     "    scale=(1e-3, 1.0),\n",
     "    e0=(0, 10, False),\n",
-    "    alpha_age=(1e-6, 1e-3),\n",
+    "    alpha_age=(1e-7, 1e-3),\n",
     "    beta=(1e-5, 1e-3),\n",
     "    methods=[\"hazard\", \"survival\"],\n",
     "    age_max=10000,\n",
@@ -483,7 +483,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.11.6"
   }
  },
  "nbformat": 4,

From d9f4a9e7a28932d6d34b42d79d265c01f06dc900 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 22 Dec 2023 18:15:13 +0900
Subject: [PATCH 143/337] Save and replay

---
 experiments/cf_asexual_evo.py             | 189 +++++++++++++++-------
 src/emevo/environments/circle_foraging.py |   1 +
 src/emevo/exp_utils.py                    |   1 +
 src/emevo/reward_fn.py                    |  12 +-
 tests/test_reward_fn.py                   |   5 +-
 5 files changed, 144 insertions(+), 64 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 2f76d898..eb7cc411 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -3,7 +3,7 @@
 import dataclasses
 import enum
 from pathlib import Path
-from typing import NamedTuple, cast
+from typing import Any, Optional, cast
 
 import chex
 import equinox as eqx
@@ -22,6 +22,9 @@
 from emevo import make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
+from emevo.environments.phyjax2d import Position
+from emevo.environments.phyjax2d import State as PhysState
+from emevo.environments.phyjax2d import StateDict
 from emevo.eqx_utils import get_slice
 from emevo.eqx_utils import where as eqx_where
 from emevo.exp_utils import BDConfig, CfConfig, GopsConfig, Log
@@ -37,6 +40,51 @@
 )
 from emevo.visualizer import SaveVideoWrapper
 
+Self = Any
+
+
+@chex.dataclass
+class SavedPhysicsState:
+    circle_axy: jax.Array
+    circle_is_active: jax.Array
+    static_circle_axy: jax.Array
+    static_circle_is_active: jax.Array
+
+    def save(self, path: Path) -> None:
+        np.savez_compressed(
+            path,
+            circle_axy=np.array(self.circle_axy),
+            circle_is_active=np.array(self.circle_is_active),
+            static_circle_axy=np.array(self.static_circle_axy),
+            static_circle_is_active=np.array(self.static_circle_is_active),
+        )
+
+    @staticmethod
+    def load(path: Path) -> Self:
+        npzfile = np.load(path)
+        return SavedPhysicsState(
+            circle_axy=jnp.array(npzfile["circle_axy"]),
+            circle_is_active=jnp.array(npzfile["circle_is_active"]),
+            static_circle_axy=jnp.array(npzfile["static_circle_axy"]),
+            static_circle_is_active=jnp.array(npzfile["static_circle_is_active"]),
+        )
+
+    def set_by_index(self, i: int, phys: StateDict) -> StateDict:
+        phys = phys.nested_replace(
+            "circle.p",
+            Position.from_axy(self.circle_axy[i]),
+        )
+        phys = phys.nested_replace("circle.is_active", self.circle_is_active[i])
+        phys = phys.nested_replace(
+            "static_circle.p",
+            Position.from_axy(self.static_circle_axy[i]),
+        )
+        phys = phys.nested_replace(
+            "static_circle.is_active",
+            self.static_circle_is_active[i],
+        )
+        return phys
+
 
 def extract_reward_input(collision: jax.Array, action: jax.Array) -> jax.Array:
     action_norm = jnp.sqrt(jnp.sum(action**2, axis=-1, keepdims=True))
@@ -52,37 +100,6 @@ class RewardKind(str, enum.Enum):
     SIGMOID = "sigmoid"
 
 
-def visualize(
-    key: chex.PRNGKey,
-    env: Env,
-    network: NormalPPONet,
-    n_steps: int,
-    videopath: Path | None,
-    headless: bool,
-) -> None:
-    keys = jax.random.split(key, n_steps + 1)
-    state, ts = env.reset(keys[0])
-    obs = ts.obs
-    backend = "headless" if headless else "pyglet"
-    visualizer = env.visualizer(state, figsize=(640.0, 640.0), backend=backend)
-    if videopath is not None:
-        visualizer = SaveVideoWrapper(visualizer, videopath, fps=60)
-
-    # Returns action for debugging
-    @eqx.filter_jit
-    def step(key: chex.PRNGKey, state: State, obs: Obs) -> tuple[State, Obs, jax.Array]:
-        net_out = vmap_apply(network, obs.as_array())
-        actions = net_out.policy().sample(seed=key)
-        next_state, timestep = env.step(state, env.act_space.sigmoid_scale(actions))
-        return next_state, timestep.obs, actions
-
-    for key in keys[1:]:
-        state, obs, act = step(key, state, obs)
-        # print(f"Act: {act[0]}")
-        visualizer.render(state)
-        visualizer.show()
-
-
 def exec_rollout(
     state: State,
     initial_obs: Obs,
@@ -93,18 +110,22 @@ def exec_rollout(
     birth_fn: bd.BirthFunction,
     prng_key: jax.Array,
     n_rollout_steps: int,
-) -> tuple[State, Rollout, Log, Obs, jax.Array]:
+) -> tuple[State, Rollout, Log, SavedPhysicsState, Obs, jax.Array]:
     def step_rollout(
         carried: tuple[State, Obs],
         key: jax.Array,
-    ) -> tuple[tuple[State, Obs], tuple[Rollout, Log]]:
+    ) -> tuple[tuple[State, Obs], tuple[Rollout, Log, SavedPhysicsState]]:
         act_key, hazard_key, birth_key = jax.random.split(key, 3)
         state_t, obs_t = carried
         obs_t_array = obs_t.as_array()
         net_out = vmap_apply(network, obs_t_array)
         actions = net_out.policy().sample(seed=act_key)
-        state_t1, timestep = env.step(state_t, env.act_space.sigmoid_scale(actions))
-        rewards = reward_fn(obs_t.collision, actions).reshape(-1, 1)
+        state_t1, timestep = env.step(
+            state_t,
+            env.act_space.sigmoid_scale(actions),  # type: ignore
+        )
+        obs_t1 = timestep.obs
+        rewards = reward_fn(obs_t1.collision, actions).reshape(-1, 1)
         rollout = Rollout(
             observations=obs_t_array,
             actions=actions,
@@ -120,12 +141,16 @@ def step_rollout(
         state_t1d = env.deactivate(state_t1, dead)
         birth_prob = birth_fn(state_t1d.status.age, state_t1d.status.energy)
         possible_parents = jnp.logical_and(
-            jnp.logical_and(jnp.logical_not(dead), state.profile.is_active()),
+            jnp.logical_and(
+                jnp.logical_not(dead),
+                state.profile.is_active(),  # type: ignore
+            ),
             jax.random.bernoulli(birth_key, p=birth_prob),
         )
         state_t1db, parents = env.activate(state_t1d, possible_parents)
         log = Log(
-            dead=jnp.where(dead, state_t.profile.unique_id, -1),
+            dead=jnp.where(dead, state_t.profile.unique_id, -1),  # type: ignore
+            got_food=obs_t1.collision[:, 1],
             parents=parents,
             rewards=rewards.ravel(),
             age=state_t1db.status.age,
@@ -134,15 +159,22 @@ def step_rollout(
             generation=state_t1db.profile.generation,
             unique_id=state_t1db.profile.unique_id,
         )
-        return (state_t1db, timestep.obs), (rollout, log)
+        phys: StateDict = state_t.physics  # type: ignore
+        phys_state = SavedPhysicsState(
+            circle_axy=phys.circle.p.into_axy(),
+            static_circle_axy=phys.static_circle.p.into_axy(),
+            circle_is_active=phys.circle.is_active,
+            static_circle_is_active=phys.static_circle.is_active,
+        )
+        return (state_t1db, obs_t1), (rollout, log, phys_state)
 
-    (state, obs), (rollout, log) = jax.lax.scan(
+    (state, obs), (rollout, log, phys_state) = jax.lax.scan(
         step_rollout,
         (state, initial_obs),
         jax.random.split(prng_key, n_rollout_steps),
     )
     next_value = vmap_value(network, obs.as_array())
-    return state, rollout, log, obs, next_value
+    return state, rollout, log, phys_state, obs, next_value
 
 
 @eqx.filter_jit
@@ -162,9 +194,9 @@ def epoch(
     opt_state: optax.OptState,
     minibatch_size: int,
     n_optim_epochs: int,
-) -> tuple[State, Obs, Log, optax.OptState, NormalPPONet]:
+) -> tuple[State, Obs, Log, SavedPhysicsState, optax.OptState, NormalPPONet]:
     keys = jax.random.split(prng_key, env.n_max_agents + 1)
-    env_state, rollout, log, obs, next_value = exec_rollout(
+    env_state, rollout, log, phys_state, obs, next_value = exec_rollout(
         state,
         initial_obs,
         env,
@@ -187,7 +219,7 @@ def epoch(
         0.2,
         0.0,
     )
-    return env_state, obs, log, opt_state, pponet
+    return env_state, obs, log, phys_state, opt_state, pponet
 
 
 def write_log(logdir: Path, log_list: list[Log], index: int) -> None:
@@ -201,7 +233,6 @@ def write_log(logdir: Path, log_list: list[Log], index: int) -> None:
         logdir.joinpath(f"log-{index}.parquet"),
         compression="zstd",
     )
-    log_list.clear()
 
 
 def save_agents(
@@ -216,6 +247,11 @@ def save_agents(
         eqx.tree_serialise_leaves(modelpath, sliced_net)
 
 
+@jax.jit
+def concat_physstates(states: list[SavedPhysicsState]) -> SavedPhysicsState:
+    return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *states)
+
+
 def run_evolution(
     *,
     key: jax.Array,
@@ -234,6 +270,7 @@ def run_evolution(
     mutation: gops.Mutation,
     logdir: Path,
     log_interval: int,
+    savestate_interval: int,
     xmax: float,
     ymax: float,
     debug_vis: bool,
@@ -287,14 +324,13 @@ def replace_net(
     else:
         visualizer = None
 
-    log_list = []
-
+    log_list, physstate_list = [], []
     reward_fn_dict = {i + 1: get_slice(reward_fn, i) for i in range(n_initial_agents)}
 
-    last_log_index = 0
+    last_log_index, last_state_index = 0, 0
     for i, key in enumerate(jax.random.split(key, n_total_steps // n_rollout_steps)):
         epoch_key, init_key = jax.random.split(key)
-        env_state, obs, log, opt_state, pponet = epoch(
+        env_state, obs, log, phys_state, opt_state, pponet = epoch(
             env_state,
             obs,
             env,
@@ -311,11 +347,12 @@ def replace_net(
             minibatch_size,
             n_optim_epochs,
         )
+
         if visualizer is not None:
             visualizer.render(env_state)
             visualizer.show()
         # Extinct?
-        n_active = jnp.sum(env_state.profile.is_active())
+        n_active = jnp.sum(env_state.profile.is_active())  # type: ignore
         if n_active == 0:
             print(f"Extinct after {i + 1} epochs")
             break
@@ -341,15 +378,27 @@ def replace_net(
             log_birth.slots,
         )
 
+        # Log
         log_list.append(log_with_step.filter_active())
         if (i + 1) % log_interval == 0:
             write_log(logdir, log_list, last_log_index + 1)
             last_log_index += 1
-    rfd_serialized = [
-        v.serialize() | {"unique_id": k} for k, v in reward_fn_dict.items()
+            log_list.clear()
+
+        # Physics state
+        physstate_list.append(phys_state)
+        if (i + 1) % savestate_interval == 0:
+            concat_physstates(physstate_list).save(
+                logdir.joinpath(f"state-{last_state_index + 1}.npz")
+            )
+            last_state_index += 1
+            physstate_list.clear()
+
+    rfd_serialised = [
+        v.serialise() | {"unique_id": k} for k, v in reward_fn_dict.items()
     ]
     pq.write_table(
-        pa.Table.from_pylist(rfd_serialized),
+        pa.Table.from_pylist(rfd_serialised),
         logdir.joinpath(f"rewards.parquet"),
     )
     if len(log_list) > 0:
@@ -377,7 +426,8 @@ def evolve(
     gopsconfig_path: Path = here.joinpath("../config/gops/20231220-mutation-01.toml"),
     reward_fn: RewardKind = RewardKind.LINEAR,
     logdir: Path = Path("./log"),
-    log_interval: int = 100,
+    log_interval: int = 1000,
+    savestate_interval: int = 100,
     debug_vis: bool = False,
 ) -> None:
     # Load config
@@ -429,6 +479,7 @@ def evolve(
         mutation=cast(gops.Mutation, mutation),
         logdir=logdir,
         log_interval=log_interval,
+        savestate_interval=savestate_interval,
         xmax=cfconfig.xlim[1],
         ymax=cfconfig.ylim[1],
         debug_vis=debug_vis,
@@ -436,8 +487,34 @@ def evolve(
 
 
 @app.command()
-def vis() -> None:
-    assert False, "Unimplemented"
+def replay(
+    physstate_path: Path,
+    n_agents: int = 20,
+    backend: str = "pyglet",  # Use "headless" for headless rendering
+    videopath: Optional[Path] = None,
+    start: int = 0,
+    end: Optional[int] = None,
+    cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
+) -> None:
+    with cfconfig_path.open("r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+    cfconfig.n_initial_agents = n_agents
+    phys_state = SavedPhysicsState.load(physstate_path)
+    env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
+    env_state, _ = env.reset(jax.random.PRNGKey(0))
+    end = end if end is not None else phys_state.circle_axy.shape[0]
+    visualizer = env.visualizer(
+        env_state,
+        figsize=(cfconfig.xlim[1] * 2, cfconfig.ylim[1] * 2),
+        backend=backend,
+    )
+    if videopath is not None:
+        visualizer = SaveVideoWrapper(visualizer, videopath, fps=60)
+    for i in range(start, end):
+        phys = phys_state.set_by_index(i, env_state.physics)
+        env_state = dataclasses.replace(env_state, physics=phys)
+        visualizer.render(env_state)
+        visualizer.show()
 
 
 if __name__ == "__main__":
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index a9a58869..8478705d 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -411,6 +411,7 @@ def __init__(
             velocity=BoxSpace(low=-MAX_VELOCITY, high=MAX_VELOCITY, shape=(2,)),
             angle=BoxSpace(low=-2 * np.pi, high=2 * np.pi, shape=()),
             angular_velocity=BoxSpace(low=-np.pi / 10, high=np.pi / 10, shape=()),
+            energy=BoxSpace(low=0.0, high=energy_capacity, shape=()),
         )
         # Obs
         self._n_sensors = n_agent_sensors
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 0511c545..79f13d67 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -103,6 +103,7 @@ def load_model(self) -> gops.Mutation | gops.Crossover:
 @chex.dataclass
 class Log:
     dead: jax.Array
+    got_food: jax.Array
     parents: jax.Array
     rewards: jax.Array
     age: jax.Array
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 7f1ba9e5..e7182c39 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -18,7 +18,7 @@
 
 class RewardFn(abc.ABC, eqx.Module):
     @abc.abstractmethod
-    def serialize(self) -> dict[str, float | NDArray]:
+    def serialise(self) -> dict[str, float | NDArray]:
         pass
 
     @abc.abstractmethod
@@ -39,7 +39,7 @@ def _item_or_np(array: jax.Array) -> float | NDArray:
 class LinearReward(RewardFn):
     weight: jax.Array
     extractor: Callable[..., jax.Array]
-    serializer: Callable[[jax.Array], dict[str, jax.Array]]
+    serialiser: Callable[[jax.Array], dict[str, jax.Array]]
 
     def __init__(
         self,
@@ -47,18 +47,18 @@ def __init__(
         n_agents: int,
         n_weights: int,
         extractor: Callable[..., jax.Array],
-        serializer: Callable[[jax.Array], dict[str, jax.Array]],
+        serialiser: Callable[[jax.Array], dict[str, jax.Array]],
     ) -> None:
         self.weight = jax.random.normal(key, (n_agents, n_weights))
         self.extractor = extractor
-        self.serializer = serializer
+        self.serialiser = serialiser
 
     def __call__(self, *args) -> jax.Array:
         extracted = self.extractor(*args)
         return jax.vmap(jnp.dot)(extracted, self.weight)
 
-    def serialize(self) -> dict[str, float | NDArray]:
-        return jax.tree_map(_item_or_np, self.serializer(self.weight))
+    def serialise(self) -> dict[str, float | NDArray]:
+        return jax.tree_map(_item_or_np, self.serialiser(self.weight))
 
 
 def mutate_reward_fn(
diff --git a/tests/test_reward_fn.py b/tests/test_reward_fn.py
index bfadf81e..447b43bb 100644
--- a/tests/test_reward_fn.py
+++ b/tests/test_reward_fn.py
@@ -28,8 +28,8 @@ def test_reward_fn(reward_fn: LinearReward) -> None:
     chex.assert_shape(reward, (10,))
 
 
-def test_serialize(reward_fn: LinearReward) -> None:
-    logd = reward_fn.serialize()
+def test_serialise(reward_fn: LinearReward) -> None:
+    logd = reward_fn.serialise()
     chex.assert_shape((logd["a"], logd["b"], logd["c"]), (10,))
 
 
@@ -53,5 +53,6 @@ def test_mutation(reward_fn: LinearReward) -> None:
     difference = reward_fn.weight[different] - mutated.weight[different]
     assert jnp.linalg.norm(difference) > 1e-6
     assert len(reward_fn_dict) == 7
+    jnp.savez
     for i in range(7):
         chex.assert_trees_all_close(mutated.weight[i], reward_fn_dict[i + 1].weight)

From 024a77e8261edd66cebbb0a105ee8b0f7657985f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Sat, 23 Dec 2023 00:08:21 +0900
Subject: [PATCH 144/337] Override some config

---
 experiments/cf_asexual_evo.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index eb7cc411..c8fc4e79 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -87,7 +87,7 @@ def set_by_index(self, i: int, phys: StateDict) -> StateDict:
 
 
 def extract_reward_input(collision: jax.Array, action: jax.Array) -> jax.Array:
-    action_norm = jnp.sqrt(jnp.sum(action**2, axis=-1, keepdims=True))
+    action_norm = jnp.sqrt(jnp.sum(action ** 2, axis=-1, keepdims=True))
     return jnp.concatenate((collision, action_norm), axis=1)
 
 
@@ -413,12 +413,15 @@ def replace_net(
 def evolve(
     seed: int = 1,
     n_agents: int = 20,
+    init_energy: float = 20.0,
+    action_cost: float = 0.0001,
+    mutation_prob: float = 0.2,
     adam_lr: float = 3e-4,
     adam_eps: float = 1e-7,
     gamma: float = 0.999,
     gae_lambda: float = 0.95,
     n_optim_epochs: int = 10,
-    minibatch_size: int = 128,
+    minibatch_size: int = 256,
     n_rollout_steps: int = 1024,
     n_total_steps: int = 1024 * 10000,
     cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
@@ -427,7 +430,7 @@ def evolve(
     reward_fn: RewardKind = RewardKind.LINEAR,
     logdir: Path = Path("./log"),
     log_interval: int = 1000,
-    savestate_interval: int = 100,
+    savestate_interval: int = 1000,
     debug_vis: bool = False,
 ) -> None:
     # Load config
@@ -443,6 +446,10 @@ def evolve(
     mutation = gopsconfig.load_model()
     # Override config
     cfconfig.n_initial_agents = n_agents
+    cfconfig.init_energy = init_energy
+    cfconfig.force_energy_consumption = action_cost
+    gopsconfig.params["mutation_prob"] = mutation_prob
+    # Make env
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
     key, reward_key = jax.random.split(jax.random.PRNGKey(seed))
     if reward_fn == RewardKind.LINEAR:

From cd6cd9bf25eaa7945283e35c8dd87ba9a5813b86 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 25 Dec 2023 16:24:31 +0900
Subject: [PATCH 145/337] Some scripts for jupyter lab analysis

---
 .gitignore                   |  1 +
 noxfile.py                   |  7 ++++++-
 requirements/cuda11_local.in |  2 ++
 requirements/cuda12_local.in |  2 ++
 requirements/jupyter.in      |  1 +
 setup-jupterlab              | 16 ++++++++++++++++
 setup-venv                   |  2 +-
 7 files changed, 29 insertions(+), 2 deletions(-)
 create mode 100644 requirements/cuda11_local.in
 create mode 100644 requirements/cuda12_local.in
 create mode 100755 setup-jupterlab

diff --git a/.gitignore b/.gitignore
index c858b045..6369e2f8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,7 @@
 **/.mypy_cache/
 .virtual_documents/
 .ipynb_checkpoints/
+analysis-notebooks/
 requirements/*.txt
 # This should be local
 pyrightconfig.json
diff --git a/noxfile.py b/noxfile.py
index 43469dd7..faaf2598 100644
--- a/noxfile.py
+++ b/noxfile.py
@@ -26,6 +26,7 @@ def compile(session: nox.Session) -> None:
     if has_cuda:
         nvcc_out = subprocess.run(["nvcc", "--version"], capture_output=True)
         is_cuda_12 = "cuda_12" in nvcc_out.stdout.decode("utf-8")
+        cuda_local = "--local-cuda" in session.posargs
 
     def _run_pip_compile(in_file: str, out_name: str) -> None:
         # If -k {out_name} is given, skip compiling
@@ -35,8 +36,12 @@ def _run_pip_compile(in_file: str, out_name: str) -> None:
         out_file = f"requirements/{out_name}.txt"
         args = ["pip-compile"]
         if has_cuda and out_name not in ["format", "lint"]:
-            if is_cuda_12:
+            if is_cuda_12 and cuda_local:
+                args.append("requirements/cuda12_local.in")
+            elif is_cuda_12:
                 args.append("requirements/cuda12.in")
+            elif cuda_local:
+                args.append("requirements/cuda11_local.in")
             else:
                 args.append("requirements/cuda11.in")
         args += [
diff --git a/requirements/cuda11_local.in b/requirements/cuda11_local.in
new file mode 100644
index 00000000..53b3763e
--- /dev/null
+++ b/requirements/cuda11_local.in
@@ -0,0 +1,2 @@
+--find-links https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+jax[cuda11_local]
diff --git a/requirements/cuda12_local.in b/requirements/cuda12_local.in
new file mode 100644
index 00000000..863efb65
--- /dev/null
+++ b/requirements/cuda12_local.in
@@ -0,0 +1,2 @@
+--find-links https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+jax[cuda12_local]
diff --git a/requirements/jupyter.in b/requirements/jupyter.in
index 9932bad5..5dc8dabb 100644
--- a/requirements/jupyter.in
+++ b/requirements/jupyter.in
@@ -6,4 +6,5 @@ jupyterlab
 jupyterlab_code_formatter
 jupyterlab-lsp
 matplotlib
+polars
 seaborn
\ No newline at end of file
diff --git a/setup-jupterlab b/setup-jupterlab
new file mode 100755
index 00000000..2e88dbb8
--- /dev/null
+++ b/setup-jupterlab
@@ -0,0 +1,16 @@
+#!/bin/bash
+set -eo pipefail
+
+if [[ ! -d .lab-venv ]]; then
+    mkdir .lab-venv
+    python3 -m venv .lab-venv
+fi
+
+if [[ ! -f requirements/jupyter.txt ]]; then
+    nox -s compile -- -k jupyter --local-cuda
+fi
+
+source .lab-venv/bin/activate
+pip install pip-tools
+pip-sync requirements/jupyter.txt
+python -m ipykernel install --user --name emevo-lab
diff --git a/setup-venv b/setup-venv
index 5fca703d..2044f898 100755
--- a/setup-venv
+++ b/setup-venv
@@ -3,7 +3,7 @@ set -eo pipefail
 
 if [[ ! -d .exp-venv ]]; then
     mkdir .exp-venv
-    python -m venv .exp-venv
+    python3 -m venv .exp-venv
 fi
 
 if [[ ! -f requirements/experiments.txt ]]; then

From 359e4306333f3fadb0919e24514b2e5d52214c02 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 26 Dec 2023 02:22:00 +0900
Subject: [PATCH 146/337] Revert cuda1x_local

---
 noxfile.py                   | 7 +------
 requirements/cuda11_local.in | 2 --
 requirements/cuda12_local.in | 2 --
 requirements/jupyter.in      | 2 +-
 setup-jupterlab              | 2 +-
 5 files changed, 3 insertions(+), 12 deletions(-)
 delete mode 100644 requirements/cuda11_local.in
 delete mode 100644 requirements/cuda12_local.in

diff --git a/noxfile.py b/noxfile.py
index faaf2598..43469dd7 100644
--- a/noxfile.py
+++ b/noxfile.py
@@ -26,7 +26,6 @@ def compile(session: nox.Session) -> None:
     if has_cuda:
         nvcc_out = subprocess.run(["nvcc", "--version"], capture_output=True)
         is_cuda_12 = "cuda_12" in nvcc_out.stdout.decode("utf-8")
-        cuda_local = "--local-cuda" in session.posargs
 
     def _run_pip_compile(in_file: str, out_name: str) -> None:
         # If -k {out_name} is given, skip compiling
@@ -36,12 +35,8 @@ def _run_pip_compile(in_file: str, out_name: str) -> None:
         out_file = f"requirements/{out_name}.txt"
         args = ["pip-compile"]
         if has_cuda and out_name not in ["format", "lint"]:
-            if is_cuda_12 and cuda_local:
-                args.append("requirements/cuda12_local.in")
-            elif is_cuda_12:
+            if is_cuda_12:
                 args.append("requirements/cuda12.in")
-            elif cuda_local:
-                args.append("requirements/cuda11_local.in")
             else:
                 args.append("requirements/cuda11.in")
         args += [
diff --git a/requirements/cuda11_local.in b/requirements/cuda11_local.in
deleted file mode 100644
index 53b3763e..00000000
--- a/requirements/cuda11_local.in
+++ /dev/null
@@ -1,2 +0,0 @@
---find-links https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
-jax[cuda11_local]
diff --git a/requirements/cuda12_local.in b/requirements/cuda12_local.in
deleted file mode 100644
index 863efb65..00000000
--- a/requirements/cuda12_local.in
+++ /dev/null
@@ -1,2 +0,0 @@
---find-links https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
-jax[cuda12_local]
diff --git a/requirements/jupyter.in b/requirements/jupyter.in
index 5dc8dabb..71e31ce4 100644
--- a/requirements/jupyter.in
+++ b/requirements/jupyter.in
@@ -1,5 +1,5 @@
 -r format.in
--e .
+-e .[video]
 ipympl
 ipywidgets
 jupyterlab
diff --git a/setup-jupterlab b/setup-jupterlab
index 2e88dbb8..6f0c23e3 100755
--- a/setup-jupterlab
+++ b/setup-jupterlab
@@ -7,7 +7,7 @@ if [[ ! -d .lab-venv ]]; then
 fi
 
 if [[ ! -f requirements/jupyter.txt ]]; then
-    nox -s compile -- -k jupyter --local-cuda
+    nox -s compile -- -k jupyter
 fi
 
 source .lab-venv/bin/activate

From c755a960482f730058e03f32274bd0fbb4e42e12 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 26 Dec 2023 19:22:37 +0900
Subject: [PATCH 147/337] Profile -> UniqueID

---
 experiments/cf_asexual_evo.py             | 105 +++++++++-------------
 src/emevo/__init__.py                     |   2 +-
 src/emevo/env.py                          |  52 +++++------
 src/emevo/environments/circle_foraging.py |  42 ++++-----
 src/emevo/exp_utils.py                    |  57 +++++++++++-
 tests/test_activate.py                    |   6 +-
 6 files changed, 141 insertions(+), 123 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index c8fc4e79..a9780bea 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -2,8 +2,9 @@
  evolution with Circle Foraging"""
 import dataclasses
 import enum
+from collections.abc import Iterable
 from pathlib import Path
-from typing import Any, Optional, cast
+from typing import Optional, cast
 
 import chex
 import equinox as eqx
@@ -22,12 +23,16 @@
 from emevo import make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
-from emevo.environments.phyjax2d import Position
-from emevo.environments.phyjax2d import State as PhysState
-from emevo.environments.phyjax2d import StateDict
 from emevo.eqx_utils import get_slice
 from emevo.eqx_utils import where as eqx_where
-from emevo.exp_utils import BDConfig, CfConfig, GopsConfig, Log
+from emevo.exp_utils import (
+    BDConfig,
+    CfConfig,
+    GopsConfig,
+    Log,
+    SavedPhysicsState,
+    SavedProfile,
+)
 from emevo.reward_fn import LinearReward, RewardFn, mutate_reward_fn
 from emevo.rl.ppo_normal import (
     NormalPPONet,
@@ -40,54 +45,9 @@
 )
 from emevo.visualizer import SaveVideoWrapper
 
-Self = Any
-
-
-@chex.dataclass
-class SavedPhysicsState:
-    circle_axy: jax.Array
-    circle_is_active: jax.Array
-    static_circle_axy: jax.Array
-    static_circle_is_active: jax.Array
-
-    def save(self, path: Path) -> None:
-        np.savez_compressed(
-            path,
-            circle_axy=np.array(self.circle_axy),
-            circle_is_active=np.array(self.circle_is_active),
-            static_circle_axy=np.array(self.static_circle_axy),
-            static_circle_is_active=np.array(self.static_circle_is_active),
-        )
-
-    @staticmethod
-    def load(path: Path) -> Self:
-        npzfile = np.load(path)
-        return SavedPhysicsState(
-            circle_axy=jnp.array(npzfile["circle_axy"]),
-            circle_is_active=jnp.array(npzfile["circle_is_active"]),
-            static_circle_axy=jnp.array(npzfile["static_circle_axy"]),
-            static_circle_is_active=jnp.array(npzfile["static_circle_is_active"]),
-        )
-
-    def set_by_index(self, i: int, phys: StateDict) -> StateDict:
-        phys = phys.nested_replace(
-            "circle.p",
-            Position.from_axy(self.circle_axy[i]),
-        )
-        phys = phys.nested_replace("circle.is_active", self.circle_is_active[i])
-        phys = phys.nested_replace(
-            "static_circle.p",
-            Position.from_axy(self.static_circle_axy[i]),
-        )
-        phys = phys.nested_replace(
-            "static_circle.is_active",
-            self.static_circle_is_active[i],
-        )
-        return phys
-
 
 def extract_reward_input(collision: jax.Array, action: jax.Array) -> jax.Array:
-    action_norm = jnp.sqrt(jnp.sum(action ** 2, axis=-1, keepdims=True))
+    action_norm = jnp.sqrt(jnp.sum(action**2, axis=-1, keepdims=True))
     return jnp.concatenate((collision, action_norm), axis=1)
 
 
@@ -143,23 +103,21 @@ def step_rollout(
         possible_parents = jnp.logical_and(
             jnp.logical_and(
                 jnp.logical_not(dead),
-                state.profile.is_active(),  # type: ignore
+                state.unique_id.is_active(),  # type: ignore
             ),
             jax.random.bernoulli(birth_key, p=birth_prob),
         )
         state_t1db, parents = env.activate(state_t1d, possible_parents)
         log = Log(
-            dead=jnp.where(dead, state_t.profile.unique_id, -1),  # type: ignore
+            dead=jnp.where(dead, state_t.unique_id.unique_id, -1),  # type: ignore
             got_food=obs_t1.collision[:, 1],
             parents=parents,
             rewards=rewards.ravel(),
             age=state_t1db.status.age,
             energy=state_t1db.status.energy,
-            birthtime=state_t1db.profile.birthtime,
-            generation=state_t1db.profile.generation,
-            unique_id=state_t1db.profile.unique_id,
+            unique_id=state_t1db.unique_id.unique_id,
         )
-        phys: StateDict = state_t.physics  # type: ignore
+        phys = state_t.physics  # type: ignore
         phys_state = SavedPhysicsState(
             circle_axy=phys.circle.p.into_axy(),
             static_circle_axy=phys.static_circle.p.into_axy(),
@@ -222,12 +180,19 @@ def epoch(
     return env_state, obs, log, phys_state, opt_state, pponet
 
 
-def write_log(logdir: Path, log_list: list[Log], index: int) -> None:
+def write_log(
+    logdir: Path,
+    log_list: list[Log],
+    index: int,
+    drop_keys: Iterable[str] = ("slots", "dead", "parents"),
+) -> None:
     log = jax.tree_map(
         lambda *args: np.array(jnp.concatenate(args, axis=0)),
         *log_list,
     )
     log_dict = dataclasses.asdict(log)
+    for drop_key in drop_keys:
+        del log_dict[drop_key]
     pq.write_table(
         pa.Table.from_pydict(log_dict),
         logdir.joinpath(f"log-{index}.parquet"),
@@ -326,6 +291,7 @@ def replace_net(
 
     log_list, physstate_list = [], []
     reward_fn_dict = {i + 1: get_slice(reward_fn, i) for i in range(n_initial_agents)}
+    profile_dict = {i + 1: SavedProfile(0, 0, i + 1) for i in range(n_initial_agents)}
 
     last_log_index, last_state_index = 0, 0
     for i, key in enumerate(jax.random.split(key, n_total_steps // n_rollout_steps)):
@@ -352,7 +318,7 @@ def replace_net(
             visualizer.render(env_state)
             visualizer.show()
         # Extinct?
-        n_active = jnp.sum(env_state.profile.is_active())  # type: ignore
+        n_active = jnp.sum(env_state.unique_id.is_active())  # type: ignore
         if n_active == 0:
             print(f"Extinct after {i + 1} epochs")
             break
@@ -377,6 +343,14 @@ def replace_net(
             log_birth.unique_id,
             log_birth.slots,
         )
+        # Update profile
+        for step, uid, parent in zip(
+            log_birth.step,
+            log_birth.unique_id,
+            log_birth.parents,
+        ):
+            uid_int = uid.item()
+            profile_dict[uid_int] = SavedProfile(step.item(), parent.item(), uid_int)
 
         # Log
         log_list.append(log_with_step.filter_active())
@@ -394,12 +368,13 @@ def replace_net(
             last_state_index += 1
             physstate_list.clear()
 
-    rfd_serialised = [
-        v.serialise() | {"unique_id": k} for k, v in reward_fn_dict.items()
+    profile_and_rewards = [
+        v.serialise() | dataclasses.asdict(profile_dict[k])
+        for k, v in reward_fn_dict.items()
     ]
     pq.write_table(
-        pa.Table.from_pylist(rfd_serialised),
-        logdir.joinpath(f"rewards.parquet"),
+        pa.Table.from_pylist(profile_and_rewards),
+        logdir.joinpath(f"profile_and_rewards.parquet"),
     )
     if len(log_list) > 0:
         write_log(logdir, log_list, last_log_index + 1)
@@ -509,7 +484,7 @@ def replay(
     phys_state = SavedPhysicsState.load(physstate_path)
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
     env_state, _ = env.reset(jax.random.PRNGKey(0))
-    end = end if end is not None else phys_state.circle_axy.shape[0]
+    end_index = end if end is not None else phys_state.circle_axy.shape[0]
     visualizer = env.visualizer(
         env_state,
         figsize=(cfconfig.xlim[1] * 2, cfconfig.ylim[1] * 2),
@@ -517,7 +492,7 @@ def replay(
     )
     if videopath is not None:
         visualizer = SaveVideoWrapper(visualizer, videopath, fps=60)
-    for i in range(start, end):
+    for i in range(start, end_index):
         phys = phys_state.set_by_index(i, env_state.physics)
         env_state = dataclasses.replace(env_state, physics=phys)
         visualizer.render(env_state)
diff --git a/src/emevo/__init__.py b/src/emevo/__init__.py
index 149781df..9fff70a7 100644
--- a/src/emevo/__init__.py
+++ b/src/emevo/__init__.py
@@ -4,7 +4,7 @@
 """
 
 
-from emevo.env import Env, Profile, Status, TimeStep
+from emevo.env import Env, Status, TimeStep, UniqueID
 from emevo.environments.registry import make, register
 from emevo.vec2d import Vec2d
 from emevo.visualizer import Visualizer
diff --git a/src/emevo/env.py b/src/emevo/env.py
index f767bab2..78c5318f 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -28,9 +28,18 @@ def step(self) -> Self:
         """Get older."""
         return replace(self, age=self.age + 1)
 
-    def activate(self, flag: jax.Array, init_energy: jax.Array) -> Self:
-        age = jnp.where(flag, 0, self.age)
-        energy = jnp.where(flag, init_energy, self.energy)
+    def activate(
+        self,
+        energy_share_ratio: float,
+        child_indices: jax.Array,
+        parent_indices: jax.Array,
+    ) -> Self:
+        age = self.age.at[child_indices].add(1)
+        shared_energy = self.energy * energy_share_ratio
+        shared_energy_with_sentinel = jnp.concatenate((shared_energy, jnp.zeros(1)))
+        shared = shared_energy_with_sentinel[parent_indices]
+        energy = self.energy.at[child_indices].set(shared)
+        energy = energy.at[parent_indices].add(-shared)
         return replace(self, age=age, energy=energy)
 
     def deactivate(self, flag: jax.Array) -> Self:
@@ -50,45 +59,30 @@ def init_status(max_n: int, init_energy: float) -> Status:
 
 
 @chex.dataclass
-class Profile:
-    """Agent profile."""
+class UniqueID:
+    """Unique ID for agents. Starts from 1."""
 
-    birthtime: jax.Array
-    generation: jax.Array
     unique_id: jax.Array
 
-    def activate(self, flag: jax.Array, step: jax.Array) -> Self:
-        birthtime = jnp.where(flag, step, self.birthtime)
-        generation = jnp.where(flag, self.generation + 1, self.generation)
+    def activate(self, flag: jax.Array) -> Self:
         unique_id = jnp.where(
             flag,
             jnp.cumsum(flag) + jnp.max(self.unique_id),
             self.unique_id,
         )
-        return Profile(
-            birthtime=birthtime,
-            generation=generation,
-            unique_id=unique_id,
-        )
+        return UniqueID(unique_id=unique_id)
 
     def deactivate(self, flag: jax.Array) -> Self:
-        return Profile(
-            birthtime=jnp.where(flag, -1, self.birthtime),
-            generation=jnp.where(flag, -1, self.generation),
-            unique_id=jnp.where(flag, -1, self.unique_id),
-        )
+        return UniqueID(unique_id=jnp.where(flag, -1, self.unique_id))
 
     def is_active(self) -> jax.Array:
-        return 0 <= self.unique_id
+        return 1 <= self.unique_id
 
 
-def init_profile(n: int, max_n: int) -> Profile:
-    minus_1 = jnp.ones(max_n - n, dtype=jnp.int32) * -1
-    return Profile(
-        birthtime=jnp.concatenate((jnp.zeros(n, dtype=jnp.int32), minus_1)),
-        generation=jnp.concatenate((jnp.zeros(n, dtype=jnp.int32), minus_1)),
-        # unique_id starts from 1
-        unique_id=jnp.concatenate((jnp.arange(1, n + 1, dtype=jnp.int32), minus_1)),
+def init_uniqueid(n: int, max_n: int) -> UniqueID:
+    zeros = jnp.zeros(max_n - n, dtype=jnp.int32)
+    return UniqueID(
+        unique_id=jnp.concatenate((jnp.arange(1, n + 1, dtype=jnp.int32), zeros)),
     )
 
 
@@ -107,7 +101,7 @@ class StateProtocol(Protocol):
 
     key: chex.PRNGKey
     step: jax.Array
-    profile: Profile
+    unique_id: UniqueID
     status: Status
     n_born_agents: jax.Array
 
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 8478705d..505558d1 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -15,12 +15,12 @@
 
 from emevo.env import (
     Env,
-    Profile,
     Status,
     TimeStep,
+    UniqueID,
     Visualizer,
-    init_profile,
     init_status,
+    init_uniqueid,
 )
 from emevo.environments.env_utils import (
     CircleCoordinate,
@@ -96,7 +96,7 @@ class CFState:
     food_loc: LocatingState
     key: chex.PRNGKey
     step: jax.Array
-    profile: Profile
+    unique_id: UniqueID
     status: Status
     n_born_agents: jax.Array
 
@@ -105,7 +105,7 @@ def stated(self) -> StateDict:
         return self.physics
 
     def is_extinct(self) -> bool:
-        return jnp.logical_not(jnp.any(self.profile.is_active())).item()
+        return jnp.logical_not(jnp.any(self.unique_id.is_active())).item()
 
 
 class Obstacle(str, enum.Enum):
@@ -651,7 +651,7 @@ def step(
             food_loc=food_loc,
             key=key,
             step=state.step + 1,
-            profile=state.profile,
+            unique_id=state.unique_id,
             status=status.step(),
             n_born_agents=state.n_born_agents,
         )
@@ -682,8 +682,8 @@ def activate(
         is_parent = _first_n_true(is_possible_parent, jnp.sum(is_replaced))
         # parent_indices := nonzero_indices(parents) + (N, N, N, ....)
         parent_indices = _nonzero(is_parent, N)
-        # empty_indices := nonzero_indices(not(is_active)) + (0, 0, 0, ....)
-        replaced_indices = _nonzero(is_replaced, N) % (N + 1)
+        # empty_indices := nonzero_indices(not(is_active)) + (N, N, N, ....)
+        replaced_indices = _nonzero(is_replaced, N)
         # To use .at[].add, append (0, 0) to sampled xy
         new_xy_with_sentinel = jnp.concatenate((new_xy, jnp.zeros((1, 2))))
         xy = circle.p.xy.at[replaced_indices].add(new_xy_with_sentinel[parent_indices])
@@ -694,29 +694,25 @@ def activate(
             state.physics,
             circle=replace(circle, p=p, is_active=is_active),
         )
-        profile = state.profile.activate(is_replaced, state.step)
-        shared_energy = state.status.energy * self._energy_share_ratio
-        shared_energy_with_sentinel = jnp.concatenate((shared_energy, jnp.zeros(1)))
-        init_energy = (
-            jnp.zeros_like(state.status.energy)
-            .at[replaced_indices]
-            .add(shared_energy_with_sentinel[parent_indices])
+        unique_id = state.unique_id.activate(is_replaced)
+        status = state.status.activate(
+            self._energy_share_ratio,
+            replaced_indices,
+            parent_indices,
         )
-        status = state.status.activate(is_replaced, init_energy=init_energy)
-        status = status.update(energy_delta=(status.energy - shared_energy) * is_parent)
         n_children = jnp.sum(is_parent)
         new_state = replace(
             state,
             physics=physics,
-            profile=profile,
+            unique_id=unique_id,
             status=status,
             agent_loc=state.agent_loc.increment(n_children),
             n_born_agents=state.n_born_agents + n_children,
             key=keys[0],
         )
-        empty_id = jnp.ones_like(state.profile.unique_id) * -1
+        empty_id = jnp.ones_like(state.unique_id.unique_id) * -1
         unique_id_with_sentinel = jnp.concatenate(
-            (state.profile.unique_id, jnp.zeros(1, dtype=jnp.int32))
+            (state.unique_id.unique_id, jnp.zeros(1, dtype=jnp.int32))
         )
         parent_id = empty_id.at[replaced_indices].set(
             unique_id_with_sentinel[parent_indices]
@@ -733,14 +729,14 @@ def deactivate(self, state: CFState, flag: jax.Array) -> CFState:
         is_active = jnp.where(flag, False, state.physics.circle.is_active)
         circle = replace(state.physics.circle, p=p, v=v, is_active=is_active)
         physics = replace(state.physics, circle=circle)
-        profile = state.profile.deactivate(flag)
+        unique_id = state.unique_id.deactivate(flag)
         status = state.status.deactivate(flag)
-        return replace(state, physics=physics, profile=profile, status=status)
+        return replace(state, physics=physics, unique_id=unique_id, status=status)
 
     def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
         physics, agent_loc, food_loc = self._initialize_physics_state(key)
         N = self.n_max_agents
-        profile = init_profile(self._n_initial_agents, N)
+        unique_id = init_uniqueid(self._n_initial_agents, N)
         status = init_status(N, self._init_energy)
         state = CFState(
             physics=physics,
@@ -750,7 +746,7 @@ def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
             food_num=self._initial_foodnum_state,
             key=key,
             step=jnp.array(0, dtype=jnp.int32),
-            profile=profile,
+            unique_id=unique_id,
             status=status,
             n_born_agents=jnp.array(self._n_initial_agents, dtype=jnp.int32),
         )
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 79f13d67..be5be299 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -3,16 +3,21 @@
 
 import dataclasses
 import importlib
+from pathlib import Path
 from typing import Any, Dict, Tuple, Type, Union
 
 import chex
 import jax
 import jax.numpy as jnp
+import numpy as np
 import serde
 
 from emevo import birth_and_death as bd
 from emevo import genetic_ops as gops
 from emevo.environments.circle_foraging import SensorRange
+from emevo.environments.phyjax2d import Position, StateDict
+
+Self = Any
 
 
 @serde.serde
@@ -108,8 +113,6 @@ class Log:
     rewards: jax.Array
     age: jax.Array
     energy: jax.Array
-    birthtime: jax.Array
-    generation: jax.Array
     unique_id: jax.Array
 
     def with_step(self, from_: int) -> LogWithStep:
@@ -150,3 +153,53 @@ def filter_birth(self) -> Any:
     def filter_death(self) -> Any:
         is_death_event = self.dead > -1
         return jax.tree_map(lambda arr: arr[is_death_event], self)
+
+
+@dataclasses.dataclass
+class SavedProfile:
+    birthtime: int
+    parent: int
+    unique_id: int
+
+
+@chex.dataclass
+class SavedPhysicsState:
+    circle_axy: jax.Array
+    circle_is_active: jax.Array
+    static_circle_axy: jax.Array
+    static_circle_is_active: jax.Array
+
+    def save(self, path: Path) -> None:
+        np.savez_compressed(
+            path,
+            circle_axy=np.array(self.circle_axy),
+            circle_is_active=np.array(self.circle_is_active),
+            static_circle_axy=np.array(self.static_circle_axy),
+            static_circle_is_active=np.array(self.static_circle_is_active),
+        )
+
+    @staticmethod
+    def load(path: Path) -> Self:
+        npzfile = np.load(path)
+        return SavedPhysicsState(
+            circle_axy=jnp.array(npzfile["circle_axy"]),
+            circle_is_active=jnp.array(npzfile["circle_is_active"]),
+            static_circle_axy=jnp.array(npzfile["static_circle_axy"]),
+            static_circle_is_active=jnp.array(npzfile["static_circle_is_active"]),
+        )
+
+    def set_by_index(self, i: int, phys: StateDict) -> StateDict:
+        phys = phys.nested_replace(
+            "circle.p",
+            Position.from_axy(self.circle_axy[i]),
+        )
+        phys = phys.nested_replace("circle.is_active", self.circle_is_active[i])
+        phys = phys.nested_replace(
+            "static_circle.p",
+            Position.from_axy(self.static_circle_axy[i]),
+        )
+        phys = phys.nested_replace(
+            "static_circle.is_active",
+            self.static_circle_is_active[i],
+        )
+        return phys
diff --git a/tests/test_activate.py b/tests/test_activate.py
index f1c5216b..0265af8d 100644
--- a/tests/test_activate.py
+++ b/tests/test_activate.py
@@ -32,12 +32,12 @@ def test_deactivate(key: chex.PRNGKey) -> None:
         [True, True, True, True, True, False, False, False, False, False]
     )
     env, state = reset_env(key)
-    chex.assert_trees_all_close(state.profile.is_active(), expected)
+    chex.assert_trees_all_close(state.unique_id.is_active(), expected)
     state = env.deactivate(state, jnp.zeros_like(expected).at[2].set(True))
     expected = jnp.array(
         [True, True, False, True, True, False, False, False, False, False]
     )
-    chex.assert_trees_all_close(state.profile.is_active(), expected)
+    chex.assert_trees_all_close(state.unique_id.is_active(), expected)
     nowhere = jnp.zeros((1, 2))
     is_nowhere = jnp.all(state.physics.circle.p.xy == nowhere, axis=-1)
     chex.assert_trees_all_close(is_nowhere, jnp.logical_not(expected))
@@ -50,7 +50,7 @@ def test_activate(key: chex.PRNGKey) -> None:
     expected_active = jnp.array(
         [True, True, True, True, True, True, True, False, False, False]
     )
-    chex.assert_trees_all_close(state.profile.is_active(), expected_active)
+    chex.assert_trees_all_close(state.unique_id.is_active(), expected_active)
     expected_parents = jnp.array([-1, -1, -1, -1, -1, 3, 5, -1, -1, -1])
     chex.assert_trees_all_close(parents, expected_parents)
     nowhere = jnp.zeros((1, 2))

From fd66e42679fdcd7792a84f54c83e598ea27e28b2 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 26 Dec 2023 19:34:24 +0900
Subject: [PATCH 148/337] Test energy share

---
 tests/test_activate.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/tests/test_activate.py b/tests/test_activate.py
index 0265af8d..abaf9d50 100644
--- a/tests/test_activate.py
+++ b/tests/test_activate.py
@@ -10,6 +10,8 @@
 
 N_MAX_AGENTS = 10
 N_INIT_AGENTS = 5
+ENERGY_SHARE_RATIO = 0.4
+INIT_ENERGY = 20.0
 
 
 @pytest.fixture
@@ -22,6 +24,8 @@ def reset_env(key: chex.PRNGKey) -> tuple[CircleForaging, CFState]:
         "CircleForaging-v0",
         n_max_agents=N_MAX_AGENTS,
         n_initial_agents=N_INIT_AGENTS,
+        init_energy=INIT_ENERGY,
+        energy_share_ratio=ENERGY_SHARE_RATIO,
     )
     state, _ = env.reset(key)
     return typing.cast(CircleForaging, env), state
@@ -45,6 +49,7 @@ def test_deactivate(key: chex.PRNGKey) -> None:
 
 def test_activate(key: chex.PRNGKey) -> None:
     env, state = reset_env(key)
+    init_energy = state.status.energy
     is_parent = jnp.zeros(N_MAX_AGENTS, dtype=bool).at[jnp.array([2, 4, 7])].set(True)
     state, parents = env.activate(state, is_parent)
     expected_active = jnp.array(
@@ -56,3 +61,10 @@ def test_activate(key: chex.PRNGKey) -> None:
     nowhere = jnp.zeros((1, 2))
     is_nowhere = jnp.all(state.physics.circle.p.xy == nowhere, axis=-1)
     chex.assert_trees_all_close(is_nowhere, jnp.logical_not(expected_active))
+    expected_energy = (
+        init_energy.at[jnp.array([2, 4])]
+        .set(INIT_ENERGY * (1.0 - ENERGY_SHARE_RATIO))
+        .at[jnp.array([5, 6])]
+        .set(INIT_ENERGY * ENERGY_SHARE_RATIO)
+    )
+    chex.assert_trees_all_close(state.status.energy, expected_energy)

From 162f6df37edc18b950f7e61467d4a2a6f6d611dc Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Tue, 26 Dec 2023 23:50:36 +0900
Subject: [PATCH 149/337] Fix CI

---
 src/emevo/eqx_utils.py  | 2 ++
 tests/test_reward_fn.py | 3 +--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/emevo/eqx_utils.py b/src/emevo/eqx_utils.py
index 99e78cd2..7f8babfb 100644
--- a/src/emevo/eqx_utils.py
+++ b/src/emevo/eqx_utils.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import TypeVar
 
 import equinox as eqx
diff --git a/tests/test_reward_fn.py b/tests/test_reward_fn.py
index 447b43bb..971797b3 100644
--- a/tests/test_reward_fn.py
+++ b/tests/test_reward_fn.py
@@ -4,8 +4,8 @@
 import pytest
 
 from emevo import genetic_ops as gops
-from emevo.reward_fn import LinearReward, mutate_reward_fn
 from emevo.eqx_utils import get_slice
+from emevo.reward_fn import LinearReward, mutate_reward_fn
 
 
 @pytest.fixture
@@ -53,6 +53,5 @@ def test_mutation(reward_fn: LinearReward) -> None:
     difference = reward_fn.weight[different] - mutated.weight[different]
     assert jnp.linalg.norm(difference) > 1e-6
     assert len(reward_fn_dict) == 7
-    jnp.savez
     for i in range(7):
         chex.assert_trees_all_close(mutated.weight[i], reward_fn_dict[i + 1].weight)

From 410b2218c2b1fe82a2e990eab66c14001c722137 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Tue, 26 Dec 2023 23:50:42 +0900
Subject: [PATCH 150/337] Big square

---
 config/env/20231226-big-square.toml | 30 +++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 config/env/20231226-big-square.toml

diff --git a/config/env/20231226-big-square.toml b/config/env/20231226-big-square.toml
new file mode 100644
index 00000000..730b7348
--- /dev/null
+++ b/config/env/20231226-big-square.toml
@@ -0,0 +1,30 @@
+n_initial_agents = 20
+n_max_agents = 200
+n_max_foods = 40
+food_num_fn = ["logistic", 20, 0.01, 40]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_radius = 120.0
+env_shape = "square"
+neighbor_stddev = 40.0
+n_agent_sensors = 16
+sensor_length = 100.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 100.0
+force_energy_consumption = 0.00025
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10

From 0a9995c7e9017c8eda45cc3afbf64f8432b49a9e Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 27 Dec 2023 14:40:29 +0900
Subject: [PATCH 151/337] e010

---
 config/bd/20231227-a035-e010.toml | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 config/bd/20231227-a035-e010.toml

diff --git a/config/bd/20231227-a035-e010.toml b/config/bd/20231227-a035-e010.toml
new file mode 100644
index 00000000..adf6caea
--- /dev/null
+++ b/config/bd/20231227-a035-e010.toml
@@ -0,0 +1,14 @@
+birth_fn = "emevo.birth_and_death.EnergyLogisticBirth"
+hazard_fn = "emevo.birth_and_death.ELGompertzHazard"
+
+[hazard_params]
+alpha = 0.35
+alpha_age = 1e-6
+beta = 3e-5
+scale = 0.1
+e0 = 0.0
+
+[birth_params]
+alpha = 0.01
+scale = 2e-4
+e0 = 10.0

From 8896ae9dda2b5e72d749d9520826d1cf000eeac3 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 27 Dec 2023 16:04:56 +0900
Subject: [PATCH 152/337] Rename center-short to center-two-thirds

---
 config/env/20231227-big-obstacle.toml     | 31 +++++++++++++++++++++++
 src/emevo/environments/circle_foraging.py |  7 ++---
 2 files changed, 33 insertions(+), 5 deletions(-)
 create mode 100644 config/env/20231227-big-obstacle.toml

diff --git a/config/env/20231227-big-obstacle.toml b/config/env/20231227-big-obstacle.toml
new file mode 100644
index 00000000..d72e418a
--- /dev/null
+++ b/config/env/20231227-big-obstacle.toml
@@ -0,0 +1,31 @@
+n_initial_agents = 20
+n_max_agents = 200
+n_max_foods = 40
+food_num_fn = ["logistic", 20, 0.01, 40]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_radius = 120.0
+env_shape = "square"
+neighbor_stddev = 40.0
+n_agent_sensors = 16
+sensor_length = 100.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 100.0
+force_energy_consumption = 0.00025
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
+obstacles = "center-two-thirds"
\ No newline at end of file
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 505558d1..19cfdee6 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -110,9 +110,8 @@ def is_extinct(self) -> bool:
 
 class Obstacle(str, enum.Enum):
     NONE = "none"
-    CENTER = "center"
     CENTER_HALF = "center-half"
-    CENTER_SHORT = "center-short"
+    CENTER_TWO_THIRDS = "center-two-thirds"
 
     def as_list(
         self,
@@ -122,11 +121,9 @@ def as_list(
         # xmin, xmax, ymin, ymax
         if self == Obstacle.NONE:
             return []
-        elif self == Obstacle.CENTER:
-            return [(Vec2d(width / 2, height / 4), Vec2d(width / 2, height))]
         elif self == Obstacle.CENTER_HALF:
             return [(Vec2d(width / 2, height / 2), Vec2d(width / 2, height))]
-        elif self == Obstacle.CENTER_SHORT:
+        elif self == Obstacle.CENTER_TWO_THIRDS:
             return [(Vec2d(width / 2, height / 3), Vec2d(width / 2, height))]
         else:
             raise ValueError(f"Unsupported Obstacle: {self}")

From aadc9979f5cfc1ff9f019cbb9f1039919f9529f2 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 27 Dec 2023 16:35:36 +0900
Subject: [PATCH 153/337] More foods

---
 config/env/20231226-big-square.toml | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/config/env/20231226-big-square.toml b/config/env/20231226-big-square.toml
index 730b7348..95a3b6cd 100644
--- a/config/env/20231226-big-square.toml
+++ b/config/env/20231226-big-square.toml
@@ -1,16 +1,15 @@
 n_initial_agents = 20
 n_max_agents = 200
-n_max_foods = 40
-food_num_fn = ["logistic", 20, 0.01, 40]
+n_max_foods = 50
+food_num_fn = ["logistic", 20, 0.01, 50]
 food_loc_fn = "gaussian"
 agent_loc_fn = "uniform"
 xlim = [0.0, 480.0]
 ylim = [0.0, 360.0]
-env_radius = 120.0
 env_shape = "square"
-neighbor_stddev = 40.0
+neighbor_stddev = 100.0
 n_agent_sensors = 16
-sensor_length = 100.0
+sensor_length = 120.0
 sensor_range = "wide"
 agent_radius = 10.0
 food_radius = 4.0

From 1c4cfc82c9b5848317d14cc3ea19164a79275df6 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 27 Dec 2023 16:45:12 +0900
Subject: [PATCH 154/337] Refine config

---
 config/env/20231226-big-square.toml   |  6 +++---
 config/env/20231227-big-obstacle.toml | 13 ++++++-------
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/config/env/20231226-big-square.toml b/config/env/20231226-big-square.toml
index 95a3b6cd..c92b0866 100644
--- a/config/env/20231226-big-square.toml
+++ b/config/env/20231226-big-square.toml
@@ -1,5 +1,5 @@
 n_initial_agents = 20
-n_max_agents = 200
+n_max_agents = 120
 n_max_foods = 50
 food_num_fn = ["logistic", 20, 0.01, 50]
 food_loc_fn = "gaussian"
@@ -20,8 +20,8 @@ angular_damping = 0.6
 max_force = 40.0
 min_force = -20.0
 init_energy = 40.0
-energy_capacity = 100.0
-force_energy_consumption = 0.00025
+energy_capacity = 120.0
+force_energy_consumption = 4e-5
 energy_share_ratio = 0.4
 n_velocity_iter = 6
 n_position_iter = 2
diff --git a/config/env/20231227-big-obstacle.toml b/config/env/20231227-big-obstacle.toml
index d72e418a..41446ca8 100644
--- a/config/env/20231227-big-obstacle.toml
+++ b/config/env/20231227-big-obstacle.toml
@@ -1,14 +1,13 @@
 n_initial_agents = 20
-n_max_agents = 200
-n_max_foods = 40
-food_num_fn = ["logistic", 20, 0.01, 40]
+n_max_agents = 120
+n_max_foods = 50
+food_num_fn = ["logistic", 20, 0.01, 50]
 food_loc_fn = "gaussian"
 agent_loc_fn = "uniform"
 xlim = [0.0, 480.0]
 ylim = [0.0, 360.0]
-env_radius = 120.0
 env_shape = "square"
-neighbor_stddev = 40.0
+neighbor_stddev = 100.0
 n_agent_sensors = 16
 sensor_length = 100.0
 sensor_range = "wide"
@@ -21,8 +20,8 @@ angular_damping = 0.6
 max_force = 40.0
 min_force = -20.0
 init_energy = 40.0
-energy_capacity = 100.0
-force_energy_consumption = 0.00025
+energy_capacity = 120.0
+force_energy_consumption = 4e-5
 energy_share_ratio = 0.4
 n_velocity_iter = 6
 n_position_iter = 2

From 0395406eff7bbc35670b7d0c2f532ea507ed85ac Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 27 Dec 2023 17:24:05 +0900
Subject: [PATCH 155/337] Tree analysis

---
 pyproject.toml                 |   3 +-
 requirements/experiments.in    |   2 +-
 requirements/jupyter.in        |   2 +-
 requirements/tests.in          |   2 +-
 src/emevo/analysis/__init__.py |   1 +
 src/emevo/analysis/tree.py     | 312 +++++++++++++++++++++++++++++++++
 tests/test_tree.py             |  74 ++++++++
 7 files changed, 392 insertions(+), 4 deletions(-)
 create mode 100644 src/emevo/analysis/__init__.py
 create mode 100644 src/emevo/analysis/tree.py
 create mode 100644 tests/test_tree.py

diff --git a/pyproject.toml b/pyproject.toml
index d29b05b3..ba3e7e6c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -31,8 +31,9 @@ dependencies = [
 dynamic = ["version"]
 
 [project.optional-dependencies]
-pyside6 = ["PySide6 >= 6.5"]
+analysis = ["networkx >= 3.0", "pygraphviz >= 1.0", "pyarrow >= 8.0"]
 video = ["imageio-ffmpeg >= 0.4"]
+widget = ["PySide6 >= 6.5"]
 
 [project.readme]
 file = "README.md"
diff --git a/requirements/experiments.in b/requirements/experiments.in
index 13a50047..09868736 100644
--- a/requirements/experiments.in
+++ b/requirements/experiments.in
@@ -1,4 +1,4 @@
--e .[video,pyside6]
+-e .[analysis,video,pyside6]
 pyarrow
 tqdm
 typer
\ No newline at end of file
diff --git a/requirements/jupyter.in b/requirements/jupyter.in
index 71e31ce4..17013ef0 100644
--- a/requirements/jupyter.in
+++ b/requirements/jupyter.in
@@ -1,5 +1,5 @@
 -r format.in
--e .[video]
+-e .[analysis,video]
 ipympl
 ipywidgets
 jupyterlab
diff --git a/requirements/tests.in b/requirements/tests.in
index 9aa41082..cc4db9b8 100644
--- a/requirements/tests.in
+++ b/requirements/tests.in
@@ -1,2 +1,2 @@
--e .
+-e .[analysis]
 pytest
\ No newline at end of file
diff --git a/src/emevo/analysis/__init__.py b/src/emevo/analysis/__init__.py
new file mode 100644
index 00000000..ea93fee5
--- /dev/null
+++ b/src/emevo/analysis/__init__.py
@@ -0,0 +1 @@
+from emevo.analysis.tree import Tree
diff --git a/src/emevo/analysis/tree.py b/src/emevo/analysis/tree.py
new file mode 100644
index 00000000..433542d9
--- /dev/null
+++ b/src/emevo/analysis/tree.py
@@ -0,0 +1,312 @@
+"""Tree data implementation used for analyzing agent's phylogeny."""
+
+from __future__ import annotations
+
+import dataclasses
+import functools
+from typing import Any, Iterable, NamedTuple, Sequence
+from weakref import ReferenceType
+from weakref import ref as make_weakref
+
+import networkx as nx
+import numpy as np
+from networkx.drawing.nx_agraph import graphviz_layout
+from numpy.typing import NDArray
+from pyarrow import Table
+
+
+class Edge(NamedTuple):
+    node: Node
+    distance: float | NDArray = 1.0
+
+
+datafield = functools.partial(dataclasses.field, compare=False, hash=False, repr=False)
+_ROOT_INDEX = -1
+
+
+@functools.total_ordering
+@dataclasses.dataclass
+class Node:
+    index: int
+    is_root: dataclasses.InitVar[bool] = dataclasses.field(default=False)
+    birth_time: int | None = None
+    parent_ref: ReferenceType[Node] | None = datafield(default=None)
+    children: list[Edge] = datafield(default_factory=list)
+    attribute: NDArray | None = datafield(default=None, repr=False)
+    info: dict[str, Any] = datafield(default_factory=dict)
+
+    def __post_init__(self, is_root: bool) -> None:
+        if not is_root and self.index < 0:
+            raise ValueError(f"Negative index {self.index} is not allowed as an index")
+
+    def add_child(self, child: Node, distance: float | NDArray = 1.0, **kwargs) -> None:
+        if child.parent_ref is not None:
+            raise RuntimeError(f"Child {child.index} already has a parent")
+        child.info = kwargs
+        self.children.append(Edge(child, distance))
+        child.parent_ref = make_weakref(self)
+
+    def sort_children(self) -> None:
+        self.children.sort(key=lambda node_and_edge: node_and_edge[0].index)
+
+    @property
+    def n_children(self) -> int:
+        return len(self.children)
+
+    @property
+    def parent(self) -> Node | None:
+        if self.parent_ref is None:
+            return None
+        else:
+            return self.parent_ref()
+
+    @functools.cached_property
+    def n_total_children(self) -> int:
+        total = 0
+        for child, _ in self.children:
+            total += 1 + child.n_total_children
+        return total
+
+    def __lt__(self, other: Any) -> bool:
+        if isinstance(other, Node):
+            return self.index < other.index
+        else:
+            return True
+
+    def ancestors(self, include_self: bool = True) -> Iterable[Node]:
+        if include_self:
+            yield self
+        parent = self.parent
+        if parent is not None and parent.index != _ROOT_INDEX:
+            yield from parent.ancestors()
+
+    def traverse(
+        self,
+        preorder: bool = True,
+        include_self: bool = True,
+    ) -> Iterable[Node]:
+        if include_self and preorder:
+            yield self
+        for child, _ in self.children:
+            yield from child.traverse(preorder)
+        if include_self and not preorder:
+            yield self
+
+
+@dataclasses.dataclass
+class Tree:
+    root: Node
+    nodes: dict[int, Node]
+
+    @staticmethod
+    def from_iter(iterator: Iterable[tuple[int, int] | tuple[int, int, dict]]) -> Tree:
+        nodes = {}
+        for item in iterator:
+            if len(item) == 2:
+                idx, parent_idx = item
+                kwargs = {}
+            else:
+                idx, parent_idx, kwargs = item
+
+            if parent_idx in nodes:
+                parent = nodes[parent_idx]
+            else:
+                parent = Node(parent_idx)
+                nodes[parent_idx] = parent
+            if idx not in nodes:
+                nodes[idx] = Node(index=idx)
+            parent.add_child(nodes[idx], **kwargs)
+
+        root = Node(index=_ROOT_INDEX, is_root=True)
+        for node in nodes.values():
+            if node.parent_ref is None:
+                root.add_child(node)
+
+            node.sort_children()
+        return Tree(root, nodes)
+
+    @staticmethod
+    def from_table(
+        table: Table,
+        initial_population: int | None = None,
+    ) -> Tree:
+        birth_steps = {}
+
+        def table_iter() -> Iterable[tuple[int, int]]:
+            for batch in table.to_batches():
+                bd = batch.to_pydict()
+                zipped = zip(bd["unique_id"], bd["parent"], bd["birthtime"])
+                for idx, pidx, step in zipped:
+                    birth_steps[idx] = step
+                    yield idx, pidx
+
+        tree = Tree.from_iter(table_iter())
+        for idx, node in tree.nodes.items():
+            if idx in birth_steps:
+                node.birth_time = birth_steps[idx]
+            else:
+                node.birth_time = 0
+
+        if initial_population is not None:
+            for i in range(initial_population):
+                if i not in tree.nodes:
+                    node = Node(index=i)
+                    tree.nodes[i] = node
+                    tree.root.add_child(node)
+                    node.birth_time = 0
+        return tree
+
+    def add_root(self, node: Node) -> None:
+        self.root.add_child(node)
+
+    def all_edges(self) -> Iterable[tuple[int, int]]:
+        for node in self.nodes.values():
+            for child, _ in node.children:
+                yield node.index, child.index
+
+    def as_networkx(self) -> nx.Graph:
+        tree = nx.Graph()
+        for node in self.nodes.values():
+            tree.add_node(node.index)
+            for child, distance in node.children:
+                if distance is None:
+                    tree.add_edge(node.index, child.index)
+                else:
+                    tree.add_edge(node.index, child.index, distance=distance)
+        return tree
+
+    def traverse(self, preorder: bool = True) -> Iterable[Node]:
+        return self.root.traverse(preorder=preorder, include_self=False)
+
+    def _splitted_roots(self, min_group_size) -> set[int]:
+        splitted_roots = set()
+
+        def split_nodes(node: Node, threshold: int) -> int:
+            n_families = 0
+            for child, _ in node.children:
+                # Number of children that are not splitted
+                n_existing_children = split_nodes(child, threshold)
+                n_families += n_existing_children
+
+            if n_families + 1 >= threshold:
+                splitted_roots.add(node.index)
+                return 0
+            else:
+                return n_families + 1
+
+        for root, _ in self.root.children:
+            if split_nodes(root, min_group_size) != 0:
+                splitted_roots.add(root.index)
+
+        return splitted_roots
+
+    def split(self, min_group_size: int) -> dict[int, int]:
+        splitted_roots = self._splitted_roots(min_group_size)
+        categ = {node.index: 0 for node in self.nodes.values()}
+
+        def colorize(node: Node, color: int) -> None:
+            categ[node.index] = color
+            for child, _ in node.children:
+                if child.index not in splitted_roots:
+                    colorize(child, color)
+
+        for i, node_idx in enumerate(splitted_roots):
+            colorize(self.nodes[node_idx], i)
+        return categ
+
+    def multilabel_split(self, min_group_size: int) -> list[set[int]]:
+        splitted_roots = self._splitted_roots(min_group_size)
+        labels = []
+
+        def children(node: Node) -> Iterable[Node]:
+            yield node
+            for child, _ in node.children:
+                if child.index not in splitted_roots:
+                    yield from children(child)
+
+        for node_idx in splitted_roots:
+            labeled_nodes = set()
+            node = self.nodes[node_idx]
+            for child in children(node):
+                labeled_nodes.add(child.index)
+            for ancestor in node.ancestors(include_self=False):
+                labeled_nodes.add(ancestor.index)
+            labels.append(labeled_nodes)
+        return labels
+
+    def as_datadict(self, split: int | dict[int, int] | None) -> dict[str, NDArray]:
+        """Returns a dict immediately convertable to Pandas dataframe"""
+
+        indices = list(self.nodes.keys())
+        data_dict = {"index": np.array(indices, dtype=int)}
+        birth_times = []
+        for node in self.nodes.values():
+            if node.birth_time is not None:
+                birth_times.append(node.birth_time)
+        if len(birth_times) == len(self.nodes):
+            data_dict["birth-step"] = np.array(birth_times, dtype=int)
+        representive_node = next(iter(self.nodes.values()))
+        for key in representive_node.info.keys():
+            collected = []
+            for node in self.nodes.values():
+                if key in node.info:
+                    collected.append(node.info[key])
+            if len(collected) == len(self.nodes):
+                data_dict[key] = np.array(collected, dtype=type(collected[0]))
+
+        if split is not None:
+            if isinstance(split, int):
+                labels = self.split(split)
+                split_group_size = split
+            else:
+                labels = split
+                split_group_size = len(set(labels.values()))
+            data_dict["label"] = np.array([labels[idx] for idx in indices], dtype=int)
+            multi_labels = self.multilabel_split(split_group_size)
+            for label, labelset in enumerate(multi_labels):
+                bool_list = [idx in labelset for idx in indices]
+                data_dict[f"in-label-{label}"] = np.array(bool_list, dtype=bool)
+
+        return data_dict
+
+    def plot(
+        self,
+        split: int | dict[int, int] | None = None,
+        palette: Sequence[tuple[float, float, float]] | None = None,
+        **kwargs,
+    ) -> None:
+        nx_graph = self.as_networkx()
+        default_kwargs = dict(
+            with_labels=False,
+            arrows=False,
+            node_size=5,
+            node_shape="o",
+            width=0.5,
+            node_color=range(len(self.nodes)),
+            cmap="plasma",
+            pos=graphviz_layout(nx_graph, prog="dot"),
+        )
+        draw_kwargs = default_kwargs | kwargs
+        if split is not None:
+            if isinstance(split, int):
+                labels = self.split(split)
+            else:
+                labels = split
+            node_colors = [labels[idx] for idx in list(nx_graph)]
+            if palette is None:
+                draw_kwargs["node_color"] = node_colors  # type: ignore
+            else:
+                draw_kwargs["node_color"] = [  # type: ignore
+                    palette[c] for c in node_colors
+                ]
+                del draw_kwargs["cmap"]
+        nx.draw(nx_graph, **draw_kwargs)
+
+    def __repr__(self) -> str:
+        repr_nodes = []
+        nodes = list(self.nodes.values())
+        for _, nodeval in zip(range(3), nodes):
+            repr_nodes.append(str(nodeval))
+        if len(nodes) > 3:
+            repr_nodes.append("...")
+        return f"Tree(root={self.root}, nodes={', '.join(repr_nodes)})"
diff --git a/tests/test_tree.py b/tests/test_tree.py
new file mode 100644
index 00000000..b76690cd
--- /dev/null
+++ b/tests/test_tree.py
@@ -0,0 +1,74 @@
+import operator
+from pathlib import Path
+
+import pyarrow.parquet as pq
+import pytest
+
+from emevo.analysis import Tree
+
+ASSET_DIR = Path(__file__).parent.joinpath("assets")
+
+
+@pytest.fixture
+def treedef() -> list[tuple[int, int]]:
+    #     0
+    #    / \
+    #   1   2
+    #  /|\  |\
+    # 3 4 5 6 7
+    #     |\
+    #     8 9
+    return [(1, 0), (4, 1), (3, 1), (5, 1), (9, 5), (8, 5), (2, 0), (6, 2), (7, 2)]
+
+
+def test_from_iter(treedef: list[tuple[int, int]]) -> None:
+    tree = Tree.from_iter(treedef)
+    preorder = list(map(operator.attrgetter("index"), tree.traverse(preorder=True)))
+    assert preorder == [0, 1, 3, 4, 5, 8, 9, 2, 6, 7]
+    postorder = list(map(operator.attrgetter("index"), tree.traverse(preorder=False)))
+    assert postorder == [3, 4, 8, 9, 5, 1, 6, 7, 2, 0]
+    assert tree.root.n_total_children == 10
+
+
+def test_split(treedef: list[tuple[int, int]]) -> None:
+    tree = Tree.from_iter(treedef)
+    sp1 = tree.split(min_group_size=3)
+    assert len(sp1) == 10
+    assert sp1[0] == 0
+    for idx in [1, 3, 4]:
+        assert sp1[idx] == 1
+    for idx in [2, 6, 7]:
+        assert sp1[idx] == 2
+    for idx in [5, 8, 9]:
+        assert sp1[idx] == 3
+
+    sp2 = tree.split(min_group_size=4)
+    assert len(sp2) == 10
+    for idx in [0, 2, 6, 7]:
+        assert sp2[idx] == 0
+    for idx in [1, 3, 4, 5, 8, 9]:
+        assert sp2[idx] == 1
+
+
+def test_multilabel_split(treedef: list[tuple[int, int]]) -> None:
+    tree = Tree.from_iter(treedef)
+    lb1 = tree.multilabel_split(min_group_size=3)
+    assert len(lb1) == 4
+    assert list(sorted(lb1[0])) == [0]
+    assert list(sorted(lb1[1])) == [0, 1, 3, 4]
+    assert list(sorted(lb1[2])) == [0, 2, 6, 7]
+    assert list(sorted(lb1[3])) == [0, 1, 5, 8, 9]
+
+
+# def test_from_table() -> None:
+#     table = pq.read_table(ASSET_DIR.joinpath("profile_and_rewards.parquet"))
+#     tree = Tree.from_table(table)
+#     for root, _ in tree.root.children:
+#         assert root.index < 10
+#         assert root.birth_time is not None
+#         for node in root.traverse():
+#             assert node.birth_time is not None
+
+#     data_dict = tree.as_datadict(split=10)
+#     for key in ["index", "birth-step", "label"]:
+#         assert key in data_dict

From da20aef59275ce96c0d211cd34240e887fb28049 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 28 Dec 2023 12:57:00 +0900
Subject: [PATCH 156/337] Test Tree.from_table

---
 tests/assets/profile_and_rewards.parquet | Bin 0 -> 4858 bytes
 tests/test_tree.py                       |  22 +++++++++++-----------
 2 files changed, 11 insertions(+), 11 deletions(-)
 create mode 100644 tests/assets/profile_and_rewards.parquet

diff --git a/tests/assets/profile_and_rewards.parquet b/tests/assets/profile_and_rewards.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..e32d4c5fa3ffb1cc823c4d02ab34897048879237
GIT binary patch
literal 4858
zcmcgweN<CN7M}-s;RS<6<)uN>8Wdx!AVE<BqU1sNP!U0^fITV!k>~;fqTtsyT1(NY
zORKinqcyea@w=AwTPsn~TI=ydShd<}S+$~I6}5hEclS3hK`h{&vwvvxcW36#y?18r
zZ)V<Tf-o|Om+*FXzSupEH}IqbAvKJFK+bMB8jdn`dtE)l`P+`iR9B#>>C&T|;pE1y
zjs~ioGm_Y$wMY0rV0GNC<=-(XPP6DBYmi$H8}G0xZdt=&mgB1GPQfYFYgiqllcyd#
zbQ3MI)%r6Et7K_^hU1LgFR?~>>VwjwjDoYqKVlV}CNrNck{jQ9e2$5g8{c1Yi8|?n
z&mx{7;6IF>(_AyKWpWZ+DPe4S@>yCroi8byKCgl&{0x4UKW}4r1ux~LY8B_2Ww=<Q
zK6WM1wW5XHz#Hz6Hilt&O^L85M7QbK=d<-Ehm7mMM;|CTc*^hISeasv$uGTuRVGhr
zH)Y*~qK0o`PNYBk_R;0p+I6g&_w?yUqzWGuYtGEbDd63dHbz;+Dp#@E?e1Fc|Cx=C
zKj<O68-Y-uAOvlPJ6{I6LPff6Fv-xS{#d%7F5fnN<{nyF2lfR)3Nm`{`3goM-{^HK
z99h14(m|7$z4QkZH5>A_pfIj8{Q>UU{_+zNJ1yrb<Za)(=&*O%^l#8*TeavZwLYn?
z2cOjsZzG&7;OXzsrLGC9rQEI3vU<7w&7CI^$A9=`8nnkhex**iEAFANWmZ3==Btyc
z7=upJx!&D~DcYwkV`KHC$2OL>$nv`f!dvG}G!c2DbFFak)=Y~CFX3&Wg?EqMSK@an
z8N8M597cI7?rUx*^&anN_$}t~Pq#$gmdl%XlV;>(<Y&%w5_g4FZfCV$cxtb^_EEEu
zUoxLonQL(8cYwLUB6E+$gJv9PaZtwWx@$NO{+h49udF~bwRrtw<jlVF%vBVmvey+x
zBe$vL*J;9!J&~!nvllK=Dm<#!QoG0lRVZwsi;qxq<A*f;w!LfDgU((7r`ZH<P6}M*
zHR?8JQ5a433#^8l>vkCjE#t~@1ge=m>jusqd8(6f+^T<7Fe*85T;D*A>!UAWaC=B_
z9a>h8m2`Iyjo}&!TgVCQ1ikgnsB7Z3%fEZ;B`jKLm&hVrS|f|iwEv664qs6g&-vxQ
zdw9i8Q=jyw=3*anyR-#?hn|%Wdz`-Y+3h>uYHb~xSd>hfI(4Fx!}(I>aaOyzz4oG)
z^Yk?v*TrEoEoqfQyM%uT4r4_QZEp1R)od%cK$o97_54vvp8cTgJQ8dF^#;zMy_1#L
zaW5uLxQ{fGgqt-uRhm714V1l_mA}ypzyItK@@=hRaM#N1gFoGgqgIw#3yajR9Dh(l
zNj7EF82;G?7;1u6pM%o6-SZg=`viI!%TrTouc6PLm_g5+W?_GNM2+trb1)i?Z0^tE
zs<edMp|N%(or2E(U=nNLj1MQslDYW8o0Q?Nf5gSWSx<Lht(<*!4r`HHeV6`%pd_OB
zpNvsYEc?&U^%;$;pHP|?F?=c0{F<dRb`mYF+?Cp9S_Fw|FuCqoDR0!sO=flMTK~AK
zVF`Z2OO|o&-b32>wqN|QVnigXNKAR-xZbfW$R|?Y&f9YM?|GMw7F9mdr|OE=4w$7a
z>HGrch32d*C+Bri<p!ztu}XWz+sS#eDZFH2t#a=0;IB#I_*u>y7t{7)h_4qXsUk8)
zGKH0KWIkFNsZ1g9l%rLKmemWbg0?bFa=slzmyQspc!+T-h?LF{C)5z^TX3lKnkU)P
zOQs+{!1K00JOlfn&)63t+5mBH5X9<8i1E=7%2<dl@es>KLEL-?V(~bLY74~dDPA1O
zLgjV=gklB;=!3ZR^AWfG0;tkHgoyeGLcav!y=4%kt0B&;fhhkHV&!gl{S2>-d*M}g
z0IGM6K+HS=;ad-}^$~80IxmKmNxJ%?o!1RwJth_wmcW2uLT-(5maW|Dja|;~F*T-q
zwA7;G`MoaHk@oZSiVyNM3(NIO?i)W2PFykFymEKm>PPdwG<>pt=GsmB%eOr{@=aLv
zuDMtD9l8%^ZDlt#FL8a3WoeW13oHebvol;*yG;31sy*$iJ*mbPX*u{yrqt>du}S#N
zZgIRx+#;p;Qe%tAKtnsg6L1G4KzpDA&=HUWEZ_xr0B-;ape-N;+<;C%H=qlk1Ns7Q
z0|SBXpeGbtkPMc2NJs!Qk$?#p>cxc(qgll--dWHmMDtfsW7nTqXsJbn)>xRYYg4T|
z?H={Xy*STZ{>7sL&gBOzO=OeDWL(@m(X+PTquRN)+7IBYb@XgvL7HpMfBq~gmn!WN
z?ZqD2((a(3<;awRmfF^DW~(RvIU7e`ee@k`WhG#MA#OA`joGK!rkSPL<^akNWv2~5
z*`Q3&>{He#6ECvmjW!P`0m_sL@Bt`8odGrQCh!(O+0p>GBuH0)GUx|@F`@-}0F=$1
z0A;fm;15s^djo-h9tZ+(bVb&KQT7A+0|Nj95CVh(bT@<ngMh(6IA8<>AOdLI7g4B3
z12I4>Fa*F}A;W+;U^ozuy)(kKXA+wB&KC^7?$4KfW2cI99&_gzZmC6#5e@OK%ie>x
zT2qZWRojvUX@@O_w@OPUMr=y%UAB1A(VInsZKW2|+biQYE}wF2%D(YC%Ce%jT*%qG
zD(AcUCx5lua%25F{q4lM{O_|u*JvO1Y1&e<={b}0re{o;?E2o@<;oflZIxd8X)o-m
zmNTNes-?EoUFEa5A5lrCrCTzx&3s$Jdv<qoz3ZKI*IUuq5T6{bD*Y1SwGQ*9YscAk
z9ROG7^Qja3Gr>pgGv}566GHpy-@32-A@<6@`mg81@ft41*K<&mzXxOcYB{B&r#B%!
zYL#3VIdVi&sPo{cPDujkZ-5XX2tp!2f5QZ!P>9GBq6HySh|Cmq5il4|YmtI5gqCPG
zmT09@O(KmDg+IawY7tpTCG8PRVig^N&^KW~U?6QK4iU$TrOM|+!;5NT$4oaTM+c1^
z6OucYb`PC}Ng8MkgHUO5wWA`%pqMOvVwF||Aq9viOi3P^m6ijK;m!P`n)!=^zUcoK
z>Oa|>JXCLv9hsY!G@1s*dJF0LF=b~`sF8CKjq#&Qt<Q&AMf6QcDw;+E2{FilxSk<G
zUIMCOK8A~-VnhS6D%L15Ld@71X?>i!>=`cmOw(x80?`{G6p5yE(ISyz3tqGwo768W
zJ$qt5kPzdtkEBK*7wbtumYlp|-i?Dc#uKR%$9D#V3p|o0iaABfo&Jrf$P@+<l?HDJ
vT=)e6>AAT9=KTDrg_;=|`O_v(&Cvt}_ty9B<1<H1NXx(E3`<A?{@3fj+nzao

literal 0
HcmV?d00001

diff --git a/tests/test_tree.py b/tests/test_tree.py
index b76690cd..ee86c193 100644
--- a/tests/test_tree.py
+++ b/tests/test_tree.py
@@ -60,15 +60,15 @@ def test_multilabel_split(treedef: list[tuple[int, int]]) -> None:
     assert list(sorted(lb1[3])) == [0, 1, 5, 8, 9]
 
 
-# def test_from_table() -> None:
-#     table = pq.read_table(ASSET_DIR.joinpath("profile_and_rewards.parquet"))
-#     tree = Tree.from_table(table)
-#     for root, _ in tree.root.children:
-#         assert root.index < 10
-#         assert root.birth_time is not None
-#         for node in root.traverse():
-#             assert node.birth_time is not None
+def test_from_table() -> None:
+    table = pq.read_table(ASSET_DIR.joinpath("profile_and_rewards.parquet"))
+    tree = Tree.from_table(table)
+    for root, _ in tree.root.children:
+        assert root.index < 10
+        assert root.birth_time is not None
+        for node in root.traverse():
+            assert node.birth_time is not None
 
-#     data_dict = tree.as_datadict(split=10)
-#     for key in ["index", "birth-step", "label"]:
-#         assert key in data_dict
+    data_dict = tree.as_datadict(split=10)
+    for key in ["index", "birth-step", "label", "in-label-0", "in-label-1"]:
+        assert key in data_dict

From 8bcdd8eb11426280761c014df968da54315af086 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 28 Dec 2023 12:58:17 +0900
Subject: [PATCH 157/337] Tweak on from_table test

---
 tests/test_tree.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_tree.py b/tests/test_tree.py
index ee86c193..87b080ac 100644
--- a/tests/test_tree.py
+++ b/tests/test_tree.py
@@ -62,7 +62,7 @@ def test_multilabel_split(treedef: list[tuple[int, int]]) -> None:
 
 def test_from_table() -> None:
     table = pq.read_table(ASSET_DIR.joinpath("profile_and_rewards.parquet"))
-    tree = Tree.from_table(table)
+    tree = Tree.from_table(table, 20)
     for root, _ in tree.root.children:
         assert root.index < 10
         assert root.birth_time is not None

From 96066f34c8b9a30d84cb42e5c9baed741992e6f3 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 28 Dec 2023 15:53:35 +0900
Subject: [PATCH 158/337] Save physics states in case of early exiting

---
 experiments/cf_asexual_evo.py | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index a9780bea..0d1c5ab1 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -293,6 +293,12 @@ def replace_net(
     reward_fn_dict = {i + 1: get_slice(reward_fn, i) for i in range(n_initial_agents)}
     profile_dict = {i + 1: SavedProfile(0, 0, i + 1) for i in range(n_initial_agents)}
 
+    def save_physstates(index: int) -> None:
+        concat_physstates(physstate_list).save(
+            logdir.joinpath(f"state-{index + 1}.npz")
+        )
+        physstate_list.clear()
+
     last_log_index, last_state_index = 0, 0
     for i, key in enumerate(jax.random.split(key, n_total_steps // n_rollout_steps)):
         epoch_key, init_key = jax.random.split(key)
@@ -362,12 +368,11 @@ def replace_net(
         # Physics state
         physstate_list.append(phys_state)
         if (i + 1) % savestate_interval == 0:
-            concat_physstates(physstate_list).save(
-                logdir.joinpath(f"state-{last_state_index + 1}.npz")
-            )
+            save_physstates(last_state_index + 1)
             last_state_index += 1
-            physstate_list.clear()
 
+    # Save logs before exiting
+    # Profile and rewards
     profile_and_rewards = [
         v.serialise() | dataclasses.asdict(profile_dict[k])
         for k, v in reward_fn_dict.items()
@@ -376,8 +381,12 @@ def replace_net(
         pa.Table.from_pylist(profile_and_rewards),
         logdir.joinpath(f"profile_and_rewards.parquet"),
     )
+    # Step log
     if len(log_list) > 0:
         write_log(logdir, log_list, last_log_index + 1)
+    # Physics state
+    if len(physstate_list) > 0:
+        save_physstates(last_state_index + 1)
 
 
 app = typer.Typer(pretty_exceptions_show_locals=False)

From 792e919ff3681690a7709dfe6cd2edf22f3bb10d Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 28 Dec 2023 18:29:26 +0900
Subject: [PATCH 159/337] Start migrating Qt widget

---
 src/emevo/environments/moderngl_vis.py        |   3 +-
 .../{qt_widget.py => environments/qt_vis.py}  | 111 ++++--------------
 src/emevo/visualizer.py                       |   7 +-
 3 files changed, 29 insertions(+), 92 deletions(-)
 rename src/emevo/{qt_widget.py => environments/qt_vis.py} (71%)

diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index 4da6e885..28645fa6 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -606,7 +606,8 @@ def render(self, state: HasStateD) -> None:
         self._window.use()
         self._renderer.render(stated=state.stated)
 
-    def show(self) -> None:
+    def show(self, *args, **kwargs) -> None:
+        del args, kwargs
         self._window.swap_buffers()
 
 
diff --git a/src/emevo/qt_widget.py b/src/emevo/environments/qt_vis.py
similarity index 71%
rename from src/emevo/qt_widget.py
rename to src/emevo/environments/qt_vis.py
index 20f4455d..7dbbc557 100644
--- a/src/emevo/qt_widget.py
+++ b/src/emevo/environments/qt_vis.py
@@ -6,12 +6,11 @@
 from collections import deque
 from collections.abc import Iterable
 from functools import partial
-from typing import Any, Callable
+from typing import Callable
 
 import moderngl
 import numpy as np
-import pymunk
-from pymunk.vec2d import Vec2d
+from numpy.typing import NDArray
 from PySide6.QtCharts import (
     QBarCategoryAxis,
     QBarSeries,
@@ -20,14 +19,13 @@
     QChartView,
     QValueAxis,
 )
-from PySide6.QtCore import QPointF, Qt, QTimer, Signal, Slot
+from PySide6.QtCore import Qt, QTimer, Signal, Slot
 from PySide6.QtGui import QGuiApplication, QMouseEvent, QPainter, QSurfaceFormat
 from PySide6.QtOpenGLWidgets import QOpenGLWidget
 from PySide6.QtWidgets import QGridLayout, QWidget
 
-from emevo.environments.pymunk_envs.moderngl_vis import MglRenderer
-from emevo.environments.pymunk_envs.pymunk_env import PymunkEnv
-from emevo.environments.pymunk_envs.pymunk_utils import CollisionType, make_filter
+from emevo.environments.moderngl_vis import MglRenderer
+from emevo.environments.phyjax2d import Space, StateDict
 
 
 def _mgl_qsurface_fmt() -> QSurfaceFormat:
@@ -40,81 +38,31 @@ def _mgl_qsurface_fmt() -> QSurfaceFormat:
     return fmt
 
 
-@dataclasses.dataclass
-class PanTool:
-    """
-    Handle mouse drag. Based on moderngl example code:
-    https://github.com/moderngl/moderngl/blob/master/examples/renderer_example.py
-    """
-
-    body: pymunk.Body | None = None
-    shape: pymunk.Shape | None = None
-    body_index: int | None = None
-    point: Vec2d = dataclasses.field(default_factory=Vec2d.zero)
-
-    def start_drag(self, point: Vec2d, shape: pymunk.Shape, body_index: int) -> None:
-        shape.color = shape.color._replace(a=100)  # type: ignore
-        self.shape = shape
-        self.body = shape.body
-        self.body_index = body_index
-        self.point = point
-
-    def dragging(self, point: Vec2d) -> bool:
-        if self.body is not None:
-            delta = point - self.point
-            self.point = point
-            self.body.position = self.body.position + delta
-            if self.body.space is not None:
-                self.body.space.reindex_shapes_for_body(self.body)
-            return True
-        else:
-            return False
-
-    def stop_drag(self, point: Vec2d) -> None:
-        if self.body is not None:
-            self.dragging(point)
-            self.shape.color = self.shape.color._replace(a=255)  # type: ignore
-            self.body = None
-            self.shape = None
-
-    @property
-    def is_dragging(self) -> bool:
-        return self.body is not None
-
-
 @dataclasses.dataclass
 class AppState:
-    pantool: PanTool = dataclasses.field(default_factory=PanTool)
+    selected: int | None = None
     paused: bool = False
     paused_before: bool = False
 
 
-def _do_nothing(_state: AppState) -> None:
-    pass
-
-
-class PymunkMglWidget(QOpenGLWidget):
+class QtVisualizer(QOpenGLWidget):
     selectionChanged = Signal(int)
 
     def __init__(
         self,
         *,
-        env: PymunkEnv,
-        timer: QTimer,
-        app_state: AppState | None = None,
+        x_range: float,
+        y_range: float,
+        space: Space,
+        stated: StateDict,
         figsize: tuple[float, float] | None = None,
-        step_fn: Callable[[AppState], Iterable[tuple[str, Any]] | None] = _do_nothing,
+        sensor_fn: Callable[[StateDict], tuple[NDArray, NDArray]] | None = None,
         parent: QWidget | None = None,
     ) -> None:
         # Set default format
         QSurfaceFormat.setDefaultFormat(_mgl_qsurface_fmt())
         super().__init__(parent)
         # init renderer
-        xlim, ylim = env.get_coordinate().bbox()
-        x_range = xlim[1] - xlim[0]
-        y_range = ylim[1] - ylim[0]
-        if figsize is None:
-            figsize = x_range * 3.0, y_range * 3.0
         self._figsize = int(figsize[0]), int(figsize[1])
         self._scaling = x_range / figsize[0], y_range / figsize[1]
         self._make_renderer = partial(
@@ -123,15 +71,14 @@ def __init__(
             screen_height=self._figsize[1],
             x_range=x_range,
             y_range=y_range,
-            env=env,
+            space=space,
+            stated=stated,
+            sensor_fn=sensor_fn,
         )
-        self._step_fn = step_fn
-        self._env = env
-        self._state = AppState() if app_state is None else app_state
+        self._state = AppState()
         self._initialized = False
-        self._timer = timer
-        self._timer.timeout.connect(self.update)  # type: ignore
         self._overlay_fns = []
+        self._initial_state = stated
 
         self.setFixedSize(*self._figsize)
         self.setMouseTracking(True)
@@ -155,22 +102,16 @@ def paintGL(self) -> None:
             self._fbo = self._ctx.detect_framebuffer()
             self._renderer = self._make_renderer(self._ctx)
             self._initialized = True
-        self.render()
+        self.render(self._initial_state)
 
-    def render(self) -> None:
-        overlays = self._step_fn(self._state)
+    def render(self, stated: StateDict) -> None:
         self._fbo.use()
         self._ctx.clear(1.0, 1.0, 1.0)
         self._renderer.render(self._env)  # type: ignore
-        if overlays is not None:
-            for overlay in overlays:
-                self._renderer.overlay(*overlay)
-
-    def _scale_position(self, position: QPointF) -> Vec2d:
-        return Vec2d(
-            position.x() * self._scaling[0],
-            (self._figsize[1] - position.y()) * self._scaling[1],
-        )
+
+    def show(self, timer: QTimer):
+        self._timer = timer
+        self._timer.timeout.connect(self.update)  # type: ignore
 
     def _emit_selected(self, index: int | None) -> None:
         if index is None:
@@ -197,12 +138,6 @@ def mousePressEvent(self, evt: QMouseEvent) -> None:
                     self._timer.stop()
                     self.update()
 
-    def mouseMoveEvent(self, evt: QMouseEvent) -> None:
-        if self._state.pantool.shape is not None:
-            new_pos = self._scale_position(evt.position())
-            if self._state.pantool.dragging(new_pos):
-                self.update()
-
     def mouseReleaseEvent(self, evt: QMouseEvent) -> None:
         if self._state.pantool.is_dragging:
             self._state.pantool.stop_drag(self._scale_position(evt.position()))
diff --git a/src/emevo/visualizer.py b/src/emevo/visualizer.py
index a1c4274e..07fd52b7 100644
--- a/src/emevo/visualizer.py
+++ b/src/emevo/visualizer.py
@@ -20,7 +20,7 @@ def render(self, state: STATE) -> Any:
         """Render image"""
         ...
 
-    def show(self) -> None:
+    def show(self, *args, **kwargs) -> None:
         """Open a GUI window"""
         ...
 
@@ -41,7 +41,7 @@ def get_image(self) -> NDArray:
     def render(self, state: STATE) -> Any:
         return self.unwrapped.render(state)
 
-    def show(self) -> None:
+    def show(self, *args, **kwargs) -> None:
         self.unwrapped.show()
 
     def overlay(self, name: str, value: Any) -> Any:
@@ -66,7 +66,8 @@ def close(self) -> None:
         if self._writer is not None:
             self._writer.close()
 
-    def show(self) -> None:
+    def show(self, *args, **kwargs) -> None:
+        del args, kwargs
         self._count += 1
         image = self.unwrapped.get_image()
         if self._writer is None:

From 15b562b90a277d894d939c20f98ca60a6ba7b032 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 28 Dec 2023 19:01:05 +0900
Subject: [PATCH 160/337] bd overrides

---
 experiments/cf_asexual_evo.py |  8 ++++++++
 src/emevo/exp_utils.py        | 13 ++++++++++++-
 2 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 0d1c5ab1..427ded22 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -411,6 +411,8 @@ def evolve(
     cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
     bdconfig_path: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
     gopsconfig_path: Path = here.joinpath("../config/gops/20231220-mutation-01.toml"),
+    birth_override: str = "",
+    hazard_override: str = "",
     reward_fn: RewardKind = RewardKind.LINEAR,
     logdir: Path = Path("./log"),
     log_interval: int = 1000,
@@ -425,8 +427,14 @@ def evolve(
     with gopsconfig_path.open("r") as f:
         gopsconfig = toml.from_toml(GopsConfig, f.read())
 
+    # Apply overrides
+    bdconfig.apply_birth_override(birth_override)
+    bdconfig.apply_hazard_override(hazard_override)
+
     # Load models
     birth_fn, hazard_fn = bdconfig.load_models()
+    print(birth_fn)
+    print(hazard_fn)
     mutation = gopsconfig.load_model()
     # Override config
     cfconfig.n_initial_agents = n_agents
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index be5be299..9969c608 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -3,6 +3,7 @@
 
 import dataclasses
 import importlib
+import json
 from pathlib import Path
 from typing import Any, Dict, Tuple, Type, Union
 
@@ -66,7 +67,7 @@ def _load_cls(cls_path: str) -> Type:
 
 
 @serde.serde
-@dataclasses.dataclass(frozen=True)
+@dataclasses.dataclass
 class BDConfig:
     birth_fn: str
     birth_params: Dict[str, float]
@@ -78,6 +79,16 @@ def load_models(self) -> tuple[bd.BirthFunction, bd.HazardFunction]:
         hazard_fn = _load_cls(self.hazard_fn)(**self.hazard_params)
         return birth_fn, hazard_fn
 
+    def apply_birth_override(self, override: str) -> None:
+        if 0 < len(override):
+            override_dict = json.loads(override)
+            self.birth_params |= override_dict
+
+    def apply_hazard_override(self, override: str) -> None:
+        if 0 < len(override):
+            override_dict = json.loads(override)
+            self.hazard_params |= override_dict
+
 
 def _resolve_cls(d: dict[str, Any]) -> GopsConfig:
     params = {}

From d7d30bf61deae9f7f785540e11dfa1af498d02ea Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Sun, 31 Dec 2023 00:25:31 +0900
Subject: [PATCH 161/337] Mutation 0401

---
 config/gops/20231231-mutation-0401.toml | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 config/gops/20231231-mutation-0401.toml

diff --git a/config/gops/20231231-mutation-0401.toml b/config/gops/20231231-mutation-0401.toml
new file mode 100644
index 00000000..27ce123a
--- /dev/null
+++ b/config/gops/20231231-mutation-0401.toml
@@ -0,0 +1,11 @@
+path = "emevo.genetic_ops.BernoulliMixtureMutation"
+
+[params]
+mutation_prob = 0.4
+
+[params.mutator]
+path = "emevo.genetic_ops.UniformMutation"
+
+[params.mutator.params]
+min_noise = -0.1
+max_noise = 0.1

From 529598d940ab1aaeab54fe8d4b49cb3fa7eb6d74 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 3 Jan 2024 13:16:13 +0900
Subject: [PATCH 162/337] Misc

---
 notebooks/bd_rate.ipynb | 31 +++++++++++++++++++++----------
 requirements.txt        | 16 ----------------
 2 files changed, 21 insertions(+), 26 deletions(-)
 delete mode 100644 requirements.txt

diff --git a/notebooks/bd_rate.ipynb b/notebooks/bd_rate.ipynb
index a09a9826..0898c2df 100644
--- a/notebooks/bd_rate.ipynb
+++ b/notebooks/bd_rate.ipynb
@@ -5,7 +5,15 @@
    "execution_count": 1,
    "id": "0dadbf8d-d3eb-42b8-a9c1-265e61f6edd8",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n"
+     ]
+    }
+   ],
    "source": [
     "import dataclasses\n",
     "from typing import Any, Literal\n",
@@ -281,14 +289,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 12,
    "id": "caf049a1-8651-46bf-82e8-84c249545b13",
-   "metadata": {},
+   "metadata": {
+    "scrolled": true
+   },
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "cc04f16e96c8494ba0af4a9f4aa396a1",
+       "model_id": "280272ef3dc745a796e3b4a7f8481575",
        "version_major": 2,
        "version_minor": 0
       },
@@ -296,25 +306,25 @@
        "VBox(children=(Text(value='figure.png', description='Filename:'), Button(description='Save File', style=Button…"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "64f42441f5b74acca4635a2e5569aa70",
+       "model_id": "5ff7bf17c4fd42d7983fb0cab52c53a3",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -331,9 +341,10 @@
     "    scale=(1e-3, 1.0),\n",
     "    e0=(0, 10, False),\n",
     "    alpha_age=(1e-7, 1e-3),\n",
+    "    alpha=(0.1, 0.5),\n",
     "    beta=(1e-5, 1e-3),\n",
     "    methods=[\"hazard\", \"survival\"],\n",
-    "    age_max=10000,\n",
+    "    age_max=200000,\n",
     "    energy_max=20,\n",
     "    hazard_cls=bd.ELGompertzHazard,\n",
     ")"
@@ -483,7 +494,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.6"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index 02b18c0c..00000000
--- a/requirements.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-#
-# This file is autogenerated by pip-compile with python 3.10
-# To update, run:
-#
-#    pip-compile pyproject.toml
-#
-cffi==1.15.0
-    # via pymunk
-loguru==0.6.0
-    # via emevo (pyproject.toml)
-numpy==1.23.0
-    # via emevo (pyproject.toml)
-pycparser==2.21
-    # via cffi
-pymunk==6.2.1
-    # via emevo (pyproject.toml)

From 20047119d3f0a87ab0df557ed1e665c0db438b53 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Fri, 5 Jan 2024 01:56:03 +0900
Subject: [PATCH 163/337] Some new configs

---
 config/bd/20240105-a2b4.toml     | 14 ++++++++++++++
 config/bd/20240105-a4b2.toml     | 14 ++++++++++++++
 config/env/20240105-big-160.toml | 29 +++++++++++++++++++++++++++++
 experiments/cf_asexual_evo.py    |  4 +---
 4 files changed, 58 insertions(+), 3 deletions(-)
 create mode 100644 config/bd/20240105-a2b4.toml
 create mode 100644 config/bd/20240105-a4b2.toml
 create mode 100644 config/env/20240105-big-160.toml

diff --git a/config/bd/20240105-a2b4.toml b/config/bd/20240105-a2b4.toml
new file mode 100644
index 00000000..f6e911ae
--- /dev/null
+++ b/config/bd/20240105-a2b4.toml
@@ -0,0 +1,14 @@
+birth_fn = "emevo.birth_and_death.EnergyLogisticBirth"
+hazard_fn = "emevo.birth_and_death.ELGompertzHazard"
+
+[hazard_params]
+alpha = 0.2
+alpha_age = 1e-6
+beta = 4e-5
+scale = 0.1
+e0 = 0.0
+
+[birth_params]
+alpha = 0.01
+scale = 2e-4
+e0 = 10.0
diff --git a/config/bd/20240105-a4b2.toml b/config/bd/20240105-a4b2.toml
new file mode 100644
index 00000000..f889c19d
--- /dev/null
+++ b/config/bd/20240105-a4b2.toml
@@ -0,0 +1,14 @@
+birth_fn = "emevo.birth_and_death.EnergyLogisticBirth"
+hazard_fn = "emevo.birth_and_death.ELGompertzHazard"
+
+[hazard_params]
+alpha = 0.4
+alpha_age = 1e-6
+beta = 2e-5
+scale = 0.1
+e0 = 0.0
+
+[birth_params]
+alpha = 0.01
+scale = 2e-4
+e0 = 10.0
diff --git a/config/env/20240105-big-160.toml b/config/env/20240105-big-160.toml
new file mode 100644
index 00000000..8e25a413
--- /dev/null
+++ b/config/env/20240105-big-160.toml
@@ -0,0 +1,29 @@
+n_initial_agents = 20
+n_max_agents = 160
+n_max_foods = 40
+food_num_fn = ["logistic", 20, 0.01, 40]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 4e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 427ded22..0c44e162 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -47,7 +47,7 @@
 
 
 def extract_reward_input(collision: jax.Array, action: jax.Array) -> jax.Array:
-    action_norm = jnp.sqrt(jnp.sum(action**2, axis=-1, keepdims=True))
+    action_norm = jnp.sqrt(jnp.sum(action ** 2, axis=-1, keepdims=True))
     return jnp.concatenate((collision, action_norm), axis=1)
 
 
@@ -433,8 +433,6 @@ def evolve(
 
     # Load models
     birth_fn, hazard_fn = bdconfig.load_models()
-    print(birth_fn)
-    print(hazard_fn)
     mutation = gopsconfig.load_model()
     # Override config
     cfconfig.n_initial_agents = n_agents

From 079962505568ec7b5a8c6a9352ff924f949e1ed1 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 5 Jan 2024 17:15:59 +0900
Subject: [PATCH 164/337] LogMode

---
 experiments/cf_asexual_evo.py | 118 +++++++++-------------------------
 pyproject.toml                |   3 +-
 src/emevo/exp_utils.py        | 118 ++++++++++++++++++++++++++++++++++
 3 files changed, 150 insertions(+), 89 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 0c44e162..795e01ee 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -2,7 +2,6 @@
  evolution with Circle Foraging"""
 import dataclasses
 import enum
-from collections.abc import Iterable
 from pathlib import Path
 from typing import Optional, cast
 
@@ -12,8 +11,6 @@
 import jax.numpy as jnp
 import numpy as np
 import optax
-import pyarrow as pa
-import pyarrow.parquet as pq
 import typer
 from serde import toml
 
@@ -30,6 +27,8 @@
     CfConfig,
     GopsConfig,
     Log,
+    Logger,
+    LogMode,
     SavedPhysicsState,
     SavedProfile,
 )
@@ -47,7 +46,7 @@
 
 
 def extract_reward_input(collision: jax.Array, action: jax.Array) -> jax.Array:
-    action_norm = jnp.sqrt(jnp.sum(action ** 2, axis=-1, keepdims=True))
+    action_norm = jnp.sqrt(jnp.sum(action**2, axis=-1, keepdims=True))
     return jnp.concatenate((collision, action_norm), axis=1)
 
 
@@ -180,43 +179,6 @@ def epoch(
     return env_state, obs, log, phys_state, opt_state, pponet
 
 
-def write_log(
-    logdir: Path,
-    log_list: list[Log],
-    index: int,
-    drop_keys: Iterable[str] = ("slots", "dead", "parents"),
-) -> None:
-    log = jax.tree_map(
-        lambda *args: np.array(jnp.concatenate(args, axis=0)),
-        *log_list,
-    )
-    log_dict = dataclasses.asdict(log)
-    for drop_key in drop_keys:
-        del log_dict[drop_key]
-    pq.write_table(
-        pa.Table.from_pydict(log_dict),
-        logdir.joinpath(f"log-{index}.parquet"),
-        compression="zstd",
-    )
-
-
-def save_agents(
-    logdir: Path,
-    net: NormalPPONet,
-    unique_id: jax.Array,
-    slots: jax.Array,
-) -> None:
-    for uid, slot in zip(np.array(unique_id), np.array(slots)):
-        sliced_net = get_slice(net, slot)
-        modelpath = logdir.joinpath(f"trained-{uid}.eqx")
-        eqx.tree_serialise_leaves(modelpath, sliced_net)
-
-
-@jax.jit
-def concat_physstates(states: list[SavedPhysicsState]) -> SavedPhysicsState:
-    return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *states)
-
-
 def run_evolution(
     *,
     key: jax.Array,
@@ -233,11 +195,9 @@ def run_evolution(
     hazard_fn: bd.HazardFunction,
     birth_fn: bd.BirthFunction,
     mutation: gops.Mutation,
-    logdir: Path,
-    log_interval: int,
-    savestate_interval: int,
     xmax: float,
     ymax: float,
+    logger: Logger,
     debug_vis: bool,
 ) -> None:
     key, net_key, reset_key = jax.random.split(key, 3)
@@ -289,17 +249,10 @@ def replace_net(
     else:
         visualizer = None
 
-    log_list, physstate_list = [], []
-    reward_fn_dict = {i + 1: get_slice(reward_fn, i) for i in range(n_initial_agents)}
-    profile_dict = {i + 1: SavedProfile(0, 0, i + 1) for i in range(n_initial_agents)}
+    for i in range(n_initial_agents):
+        logger.reward_fn_dict[i + 1] = get_slice(reward_fn, i)
+        logger.profile_dict[i + 1] = SavedProfile(0, 0, i + 1)
 
-    def save_physstates(index: int) -> None:
-        concat_physstates(physstate_list).save(
-            logdir.joinpath(f"state-{index + 1}.npz")
-        )
-        physstate_list.clear()
-
-    last_log_index, last_state_index = 0, 0
     for i, key in enumerate(jax.random.split(key, n_total_steps // n_rollout_steps)):
         epoch_key, init_key = jax.random.split(key)
         env_state, obs, log, phys_state, opt_state, pponet = epoch(
@@ -332,7 +285,7 @@ def save_physstates(index: int) -> None:
         # Save network
         log_with_step = log.with_step(i * n_rollout_steps)
         log_death = log_with_step.filter_death()
-        save_agents(logdir, pponet, log_death.dead, log_death.slots)
+        logger.save_agents(pponet, log_death.dead, log_death.slots)
         log_birth = log_with_step.filter_birth()
         # Initialize network and adam state for new agents
         is_new = jnp.zeros(env.n_max_agents, dtype=bool).at[log_birth.slots].set(True)
@@ -342,7 +295,7 @@ def save_physstates(index: int) -> None:
         # Mutation
         reward_fn = mutate_reward_fn(
             key,
-            reward_fn_dict,
+            logger.reward_fn_dict,
             reward_fn,
             mutation,
             log_birth.parents,
@@ -355,38 +308,21 @@ def save_physstates(index: int) -> None:
             log_birth.unique_id,
             log_birth.parents,
         ):
-            uid_int = uid.item()
-            profile_dict[uid_int] = SavedProfile(step.item(), parent.item(), uid_int)
-
-        # Log
-        log_list.append(log_with_step.filter_active())
-        if (i + 1) % log_interval == 0:
-            write_log(logdir, log_list, last_log_index + 1)
-            last_log_index += 1
-            log_list.clear()
-
-        # Physics state
-        physstate_list.append(phys_state)
-        if (i + 1) % savestate_interval == 0:
-            save_physstates(last_state_index + 1)
-            last_state_index += 1
+            ui = uid.item()
+            logger.profile_dict[ui] = SavedProfile(step.item(), parent.item(), ui)
+
+        # Push log and physics state
+        logger.push_log(log_with_step.filter_active())
+        logger.push_physstate(phys_state)
 
     # Save logs before exiting
-    # Profile and rewards
-    profile_and_rewards = [
-        v.serialise() | dataclasses.asdict(profile_dict[k])
-        for k, v in reward_fn_dict.items()
-    ]
-    pq.write_table(
-        pa.Table.from_pylist(profile_and_rewards),
-        logdir.joinpath(f"profile_and_rewards.parquet"),
+    logger.finalize()
+    is_active = env_state.unique_id.is_active()
+    logger.save_agents(
+        pponet,
+        env_state.unique_id.unique_id[is_active],
+        jnp.arange(len(is_active))[is_active],
     )
-    # Step log
-    if len(log_list) > 0:
-        write_log(logdir, log_list, last_log_index + 1)
-    # Physics state
-    if len(physstate_list) > 0:
-        save_physstates(last_state_index + 1)
 
 
 app = typer.Typer(pretty_exceptions_show_locals=False)
@@ -415,6 +351,7 @@ def evolve(
     hazard_override: str = "",
     reward_fn: RewardKind = RewardKind.LINEAR,
     logdir: Path = Path("./log"),
+    log_mode: LogMode = LogMode.FULL,
     log_interval: int = 1000,
     savestate_interval: int = 1000,
     debug_vis: bool = False,
@@ -459,6 +396,13 @@ def evolve(
         assert False, "Unimplemented"
     else:
         raise ValueError(f"Invalid reward_fn {reward_fn}")
+
+    logger = Logger(
+        logdir=logdir,
+        mode=log_mode,
+        log_interval=log_interval,
+        savestate_interval=savestate_interval,
+    )
     run_evolution(
         key=key,
         env=env,
@@ -474,11 +418,9 @@ def evolve(
         hazard_fn=hazard_fn,
         birth_fn=birth_fn,
         mutation=cast(gops.Mutation, mutation),
-        logdir=logdir,
-        log_interval=log_interval,
-        savestate_interval=savestate_interval,
         xmax=cfconfig.xlim[1],
         ymax=cfconfig.ylim[1],
+        logger=logger,
         debug_vis=debug_vis,
     )
 
diff --git a/pyproject.toml b/pyproject.toml
index ba3e7e6c..da993114 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -25,13 +25,14 @@ dependencies = [
     "moderngl >= 5.6",
     "moderngl-window >= 2.4",
     "jax >= 0.4",
+    "pyarrow >= 8.0",
     "pyserde[toml] >= 0.12",
     "optax >= 0.1",
 ]
 dynamic = ["version"]
 
 [project.optional-dependencies]
-analysis = ["networkx >= 3.0", "pygraphviz >= 1.0", "pyarrow >= 8.0"]
+analysis = ["networkx >= 3.0", "pygraphviz >= 1.0"]
 video = ["imageio-ffmpeg >= 0.4"]
 widget = ["PySide6 >= 6.5"]
 
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 9969c608..05b9ebac 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -2,21 +2,27 @@
 from __future__ import annotations
 
 import dataclasses
+import enum
 import importlib
 import json
 from pathlib import Path
 from typing import Any, Dict, Tuple, Type, Union
 
 import chex
+import equinox as eqx
 import jax
 import jax.numpy as jnp
 import numpy as np
+import pyarrow as pa
+import pyarrow.parquet as pq
 import serde
 
 from emevo import birth_and_death as bd
 from emevo import genetic_ops as gops
 from emevo.environments.circle_foraging import SensorRange
 from emevo.environments.phyjax2d import Position, StateDict
+from emevo.eqx_utils import get_slice
+from emevo.reward_fn import RewardFn
 
 Self = Any
 
@@ -214,3 +220,115 @@ def set_by_index(self, i: int, phys: StateDict) -> StateDict:
             self.static_circle_is_active[i],
         )
         return phys
+
+
+@jax.jit
+def concat_physstates(states: list[SavedPhysicsState]) -> SavedPhysicsState:
+    return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *states)
+
+
+class LogMode(str, enum.Enum):
+    NONE = "none"
+    REWARD_ONLY = "reward-only"
+    REWARD_AND_LOG = "reward-and-log"
+    FULL = "full"
+
+
+def _default_dropped_keys() -> list[str]:
+    return ["slots", "dead", "parents"]
+
+
+@dataclasses.dataclass
+class Logger:
+    logdir: Path
+    mode: LogMode
+    log_interval: int
+    savestate_interval: int
+    dropped_keys: list[str] = dataclasses.field(default_factory=_default_dropped_keys)
+    reward_fn_dict: dict[int, RewardFn] = dataclasses.field(default_factory=dict)
+    profile_dict: dict[int, SavedProfile] = dataclasses.field(default_factory=dict)
+    _log_list: list[Log] = dataclasses.field(default_factory=list, init=False)
+    _physstate_list: list[SavedPhysicsState] = dataclasses.field(
+        default_factory=list,
+        init=False,
+    )
+    _log_index: int = dataclasses.field(default=1, init=False)
+    _physstate_index: int = dataclasses.field(default=1, init=False)
+
+    def push_log(self, log: Log) -> None:
+        if self.mode not in [LogMode.FULL, LogMode.REWARD_AND_LOG]:
+            return
+
+        self._log_list.append(log)
+
+        if len(self._log_list) % self.log_interval == 0:
+            self._save_log()
+
+    def _save_log(self) -> None:
+        if len(self._log_list) == 0:
+            return
+
+        all_log = jax.tree_map(
+            lambda *args: np.array(jnp.concatenate(args, axis=0)),
+            *self._log_list,
+        )
+        log_dict = dataclasses.asdict(all_log)
+        for dropped_key in self.dropped_keys:
+            del log_dict[dropped_key]
+        pq.write_table(
+            pa.Table.from_pydict(log_dict),
+            self.logdir.joinpath(f"log-{self._log_index}.parquet"),
+            compression="zstd",
+        )
+        self._log_index += 1
+        self._log_list.clear()
+
+    def push_physstate(self, phys_state: SavedPhysicsState) -> None:
+        if self.mode != LogMode.FULL:
+            return
+
+        self._physstate_list.append(phys_state)
+
+        if len(self._physstate_list) % self.savestate_interval != 0:
+            self._save_physstate()
+
+    def _save_physstate(self) -> None:
+        if len(self._physstate_list) == 0:
+            return
+
+        concat_physstates(self._physstate_list).save(
+            self.logdir.joinpath(f"state-{self._physstate_index + 1}.npz")
+        )
+        self._physstate_index += 1
+        self._physstate_list.clear()
+
+    def save_agents(
+        self,
+        net: eqx.Module,
+        unique_id: jax.Array,
+        slots: jax.Array,
+    ) -> None:
+        if self.mode != LogMode.FULL:
+            return
+
+        for uid, slot in zip(np.array(unique_id), np.array(slots)):
+            sliced_net = get_slice(net, slot)
+            modelpath = self.logdir.joinpath(f"trained-{uid}.eqx")
+            eqx.tree_serialise_leaves(modelpath, sliced_net)
+
+    def finalize(self) -> None:
+        if self.mode != LogMode.NONE:
+            profile_and_rewards = [
+                v.serialise() | dataclasses.asdict(self.profile_dict[k])
+                for k, v in self.reward_fn_dict.items()
+            ]
+            pq.write_table(
+                pa.Table.from_pylist(profile_and_rewards),
+                self.logdir.joinpath(f"profile_and_rewards.parquet"),
+            )
+
+        if self.mode in [LogMode.FULL, LogMode.REWARD_AND_LOG]:
+            self._save_log()
+
+        if self.mode == LogMode.FULL:
+            self._save_physstate()

From 268966d23a6fb6ab2510dc761c1d568b299a2ced Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 5 Jan 2024 19:00:13 +0900
Subject: [PATCH 165/337] Sigmoid reward

---
 experiments/cf_asexual_evo.py | 41 ++++++++++++++++++++++++++++++-----
 src/emevo/reward_fn.py        | 30 +++++++++++++++++++++++++
 tests/test_reward_fn.py       | 25 ++++++++++++++++-----
 3 files changed, 85 insertions(+), 11 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 795e01ee..fa950d1f 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -32,7 +32,7 @@
     SavedPhysicsState,
     SavedProfile,
 )
-from emevo.reward_fn import LinearReward, RewardFn, mutate_reward_fn
+from emevo.reward_fn import LinearReward, RewardFn, SigmoidReward, mutate_reward_fn
 from emevo.rl.ppo_normal import (
     NormalPPONet,
     Rollout,
@@ -45,11 +45,24 @@
 from emevo.visualizer import SaveVideoWrapper
 
 
-def extract_reward_input(collision: jax.Array, action: jax.Array) -> jax.Array:
+def extract_reward_linear(
+    collision: jax.Array,
+    action: jax.Array,
+    _: jax.Array,
+) -> jax.Array:
     action_norm = jnp.sqrt(jnp.sum(action**2, axis=-1, keepdims=True))
     return jnp.concatenate((collision, action_norm), axis=1)
 
 
+def extract_reward_sigmoid(
+    collision: jax.Array,
+    action: jax.Array,
+    energy: jax.Array,
+) -> tuple[jax.Array, jax.Array]:
+    action_norm = jnp.sqrt(jnp.sum(action**2, axis=-1, keepdims=True))
+    return jnp.concatenate((collision, action_norm), axis=1), energy
+
+
 def slice_last(w: jax.Array, i: int) -> jax.Array:
     return jnp.squeeze(jax.lax.slice_in_dim(w, i, i + 1, axis=-1))
 
@@ -84,7 +97,8 @@ def step_rollout(
             env.act_space.sigmoid_scale(actions),  # type: ignore
         )
         obs_t1 = timestep.obs
-        rewards = reward_fn(obs_t1.collision, actions).reshape(-1, 1)
+        energy = state_t.status.energy
+        rewards = reward_fn(obs_t1.collision, actions, energy).reshape(-1, 1)
         rollout = Rollout(
             observations=obs_t_array,
             actions=actions,
@@ -384,16 +398,31 @@ def evolve(
             reward_key,
             cfconfig.n_max_agents,
             4,
-            extract_reward_input,
+            extract_reward_linear,
             lambda w: {
                 "agent": slice_last(w, 0),
                 "food": slice_last(w, 1),
                 "wall": slice_last(w, 2),
-                "energy": slice_last(w, 3),
+                "action": slice_last(w, 3),
             },
         )
     elif reward_fn == RewardKind.SIGMOID:
-        assert False, "Unimplemented"
+        reward_fn_instance = SigmoidReward(
+            reward_key,
+            cfconfig.n_max_agents,
+            4,
+            extract_reward_sigmoid,
+            lambda w, alpha: {
+                "w_agent": slice_last(w, 0),
+                "w_food": slice_last(w, 1),
+                "w_wall": slice_last(w, 2),
+                "w_action": slice_last(w, 3),
+                "alpha_agent": slice_last(alpha, 0),
+                "alpha_food": slice_last(alpha, 1),
+                "alpha_wall": slice_last(alpha, 2),
+                "alpha_action": slice_last(alpha, 3),
+            },
+        )
     else:
         raise ValueError(f"Invalid reward_fn {reward_fn}")
 
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index e7182c39..dcee22ea 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -61,6 +61,36 @@ def serialise(self) -> dict[str, float | NDArray]:
         return jax.tree_map(_item_or_np, self.serialiser(self.weight))
 
 
+class SigmoidReward(RewardFn):
+    weight: jax.Array
+    alpha: jax.Array
+    extractor: Callable[..., tuple[jax.Array, jax.Array]]
+    serialiser: Callable[[jax.Array, jax.Array], dict[str, jax.Array]]
+
+    def __init__(
+        self,
+        key: chex.PRNGKey,
+        n_agents: int,
+        n_weights: int,
+        extractor: Callable[..., tuple[jax.Array, jax.Array]],
+        serialiser: Callable[[jax.Array, jax.Array], dict[str, jax.Array]],
+    ) -> None:
+        k1, k2 = jax.random.split(key)
+        self.weight = jax.random.normal(k1, (n_agents, n_weights))
+        self.alpha = jax.random.normal(k2, (n_agents, n_weights))
+        self.extractor = extractor
+        self.serialiser = serialiser
+
+    def __call__(self, *args) -> jax.Array:
+        extracted, energy = self.extractor(*args)
+        energy_alpha = energy.reshape(-1, 1) * self.alpha  # (N, n_weights)
+        filtered = extracted / (1.0 + jnp.exp(-energy_alpha))
+        return jax.vmap(jnp.dot)(filtered, self.weight)
+
+    def serialise(self) -> dict[str, float | NDArray]:
+        return jax.tree_map(_item_or_np, self.serialiser(self.weight, self.alpha))
+
+
 def mutate_reward_fn(
     key: chex.PRNGKey,
     reward_fn_dict: dict[int, RF],
diff --git a/tests/test_reward_fn.py b/tests/test_reward_fn.py
index 971797b3..4d022e5a 100644
--- a/tests/test_reward_fn.py
+++ b/tests/test_reward_fn.py
@@ -5,14 +5,15 @@
 
 from emevo import genetic_ops as gops
 from emevo.eqx_utils import get_slice
-from emevo.reward_fn import LinearReward, mutate_reward_fn
+from emevo.reward_fn import LinearReward, SigmoidReward, mutate_reward_fn
+
+
+def slice_last(w: jax.Array, i: int) -> jax.Array:
+    return jnp.squeeze(jax.lax.slice_in_dim(w, i, i + 1, axis=-1))
 
 
 @pytest.fixture
 def reward_fn() -> LinearReward:
-    def slice_last(w: jax.Array, i: int) -> jax.Array:
-        return jnp.squeeze(jax.lax.slice_in_dim(w, i, i + 1, axis=-1))
-
     return LinearReward(
         jax.random.PRNGKey(43),
         10,
@@ -22,12 +23,26 @@ def slice_last(w: jax.Array, i: int) -> jax.Array:
     )
 
 
-def test_reward_fn(reward_fn: LinearReward) -> None:
+def test_linear_reward_fn(reward_fn: LinearReward) -> None:
     inputs = jnp.zeros((10, 3))
     reward = reward_fn(inputs)
     chex.assert_shape(reward, (10,))
 
 
+def test_sigmoid_reward_fn() -> None:
+    inputs = jnp.zeros((10, 3))
+    energy = jnp.zeros((10, 1))
+    reward_fn = SigmoidReward(
+        jax.random.PRNGKey(43),
+        10,
+        3,
+        lambda x, y: (x, y),  # Nothing to do
+        lambda _, __: {},
+    )
+    reward = reward_fn(inputs, energy)
+    chex.assert_shape(reward, (10,))
+
+
 def test_serialise(reward_fn: LinearReward) -> None:
     logd = reward_fn.serialise()
     chex.assert_shape((logd["a"], logd["b"], logd["c"]), (10,))

From 2c1def82fe6e085884e381390e7318d71f6f1def Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Sun, 7 Jan 2024 00:57:07 +0900
Subject: [PATCH 166/337] a2b2

---
 config/bd/20240107-a2b2.toml | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 config/bd/20240107-a2b2.toml

diff --git a/config/bd/20240107-a2b2.toml b/config/bd/20240107-a2b2.toml
new file mode 100644
index 00000000..49436677
--- /dev/null
+++ b/config/bd/20240107-a2b2.toml
@@ -0,0 +1,14 @@
+birth_fn = "emevo.birth_and_death.EnergyLogisticBirth"
+hazard_fn = "emevo.birth_and_death.ELGompertzHazard"
+
+[hazard_params]
+alpha = 0.2
+alpha_age = 1e-6
+beta = 2e-5
+scale = 0.1
+e0 = 0.0
+
+[birth_params]
+alpha = 0.01
+scale = 2e-4
+e0 = 10.0

From 7ba7ebaffd9390a3b5d11f614820b7fc0cd3cfa1 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sun, 7 Jan 2024 23:01:49 +0900
Subject: [PATCH 167/337] Update tree.py to use with the current log format

---
 src/emevo/analysis/tree.py | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/src/emevo/analysis/tree.py b/src/emevo/analysis/tree.py
index 433542d9..31985566 100644
--- a/src/emevo/analysis/tree.py
+++ b/src/emevo/analysis/tree.py
@@ -4,7 +4,8 @@
 
 import dataclasses
 import functools
-from typing import Any, Iterable, NamedTuple, Sequence
+from collections.abc import Iterable, Sequence
+from typing import Any, NamedTuple
 from weakref import ReferenceType
 from weakref import ref as make_weakref
 
@@ -99,8 +100,13 @@ class Tree:
     nodes: dict[int, Node]
 
     @staticmethod
-    def from_iter(iterator: Iterable[tuple[int, int] | tuple[int, int, dict]]) -> Tree:
+    def from_iter(
+        iterator: Iterable[tuple[int, int] | tuple[int, int, dict]],
+        root_idx: int = -1,
+    ) -> Tree:
         nodes = {}
+        root = Node(index=_ROOT_INDEX, is_root=True)
+
         for item in iterator:
             if len(item) == 2:
                 idx, parent_idx = item
@@ -110,6 +116,8 @@ def from_iter(iterator: Iterable[tuple[int, int] | tuple[int, int, dict]]) -> Tr
 
             if parent_idx in nodes:
                 parent = nodes[parent_idx]
+            elif parent_idx == root_idx:
+                parent = root
             else:
                 parent = Node(parent_idx)
                 nodes[parent_idx] = parent
@@ -117,7 +125,6 @@ def from_iter(iterator: Iterable[tuple[int, int] | tuple[int, int, dict]]) -> Tr
                 nodes[idx] = Node(index=idx)
             parent.add_child(nodes[idx], **kwargs)
 
-        root = Node(index=_ROOT_INDEX, is_root=True)
         for node in nodes.values():
             if node.parent_ref is None:
                 root.add_child(node)
@@ -129,6 +136,7 @@ def from_iter(iterator: Iterable[tuple[int, int] | tuple[int, int, dict]]) -> Tr
     def from_table(
         table: Table,
         initial_population: int | None = None,
+        root_idx: int = -1,
     ) -> Tree:
         birth_steps = {}
 
@@ -140,7 +148,7 @@ def table_iter() -> Iterable[tuple[int, int]]:
                     birth_steps[idx] = step
                     yield idx, pidx
 
-        tree = Tree.from_iter(table_iter())
+        tree = Tree.from_iter(table_iter(), root_idx=root_idx)
         for idx, node in tree.nodes.items():
             if idx in birth_steps:
                 node.birth_time = birth_steps[idx]
@@ -148,7 +156,7 @@ def table_iter() -> Iterable[tuple[int, int]]:
                 node.birth_time = 0
 
         if initial_population is not None:
-            for i in range(initial_population):
+            for i in range(1, initial_population + 1):
                 if i not in tree.nodes:
                     node = Node(index=i)
                     tree.nodes[i] = node
@@ -238,13 +246,7 @@ def as_datadict(self, split: int | dict[int, int] | None) -> dict[str, NDArray]:
         """Returns a dict immediately convertable to Pandas dataframe"""
 
         indices = list(self.nodes.keys())
-        data_dict = {"index": np.array(indices, dtype=int)}
-        birth_times = []
-        for node in self.nodes.values():
-            if node.birth_time is not None:
-                birth_times.append(node.birth_time)
-        if len(birth_times) == len(self.nodes):
-            data_dict["birth-step"] = np.array(birth_times, dtype=int)
+        data_dict = {"unique_id": np.array(indices, dtype=int)}
         representive_node = next(iter(self.nodes.values()))
         for key in representive_node.info.keys():
             collected = []

From 4f487a9c7204eca2794442427b7a31a27b068075 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Tue, 9 Jan 2024 00:33:58 +0900
Subject: [PATCH 168/337] Remove experiments.in

---
 requirements/experiments.in | 4 ----
 1 file changed, 4 deletions(-)
 delete mode 100644 requirements/experiments.in

diff --git a/requirements/experiments.in b/requirements/experiments.in
deleted file mode 100644
index 09868736..00000000
--- a/requirements/experiments.in
+++ /dev/null
@@ -1,4 +0,0 @@
--e .[analysis,video,pyside6]
-pyarrow
-tqdm
-typer
\ No newline at end of file

From 08c95b20575334b8c1244b089570a7e53419b95a Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 9 Jan 2024 12:44:33 +0900
Subject: [PATCH 169/337] Isolation/two seasons

---
 config/env/20240109-isolatation.toml |  0
 config/env/20240109-isolation.toml   | 30 ++++++++++++++++++++++++++++
 config/env/20240109-two-seasons.toml | 30 ++++++++++++++++++++++++++++
 src/emevo/environments/env_utils.py  |  4 +++-
 4 files changed, 63 insertions(+), 1 deletion(-)
 create mode 100644 config/env/20240109-isolatation.toml
 create mode 100644 config/env/20240109-isolation.toml
 create mode 100644 config/env/20240109-two-seasons.toml

diff --git a/config/env/20240109-isolatation.toml b/config/env/20240109-isolatation.toml
new file mode 100644
index 00000000..e69de29b
diff --git a/config/env/20240109-isolation.toml b/config/env/20240109-isolation.toml
new file mode 100644
index 00000000..3c8b4e7c
--- /dev/null
+++ b/config/env/20240109-isolation.toml
@@ -0,0 +1,30 @@
+n_initial_agents = 20
+n_max_agents = 120
+n_max_foods = 50
+food_num_fn = ["logistic", 20, 0.01, 50]
+food_loc_fn = "gaussian-mixture"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 100.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
+obstacles = "center-half"
\ No newline at end of file
diff --git a/config/env/20240109-two-seasons.toml b/config/env/20240109-two-seasons.toml
new file mode 100644
index 00000000..e6258e81
--- /dev/null
+++ b/config/env/20240109-two-seasons.toml
@@ -0,0 +1,30 @@
+n_initial_agents = 20
+n_max_agents = 120
+n_max_foods = 50
+food_num_fn = ["logistic", 20, 0.01, 50]
+food_loc_fn = "switching"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 100.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
+obstacles = "none"
\ No newline at end of file
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index 7ad0ccaf..67539bfb 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -263,7 +263,9 @@ def __init__(
                 locfn_list.append(fn_or_base)
             else:
                 name, *args = fn_or_base
-                locfn_list.append(Locating(name)(*args))
+                fn, state = Locating(name)(*args)
+                del state
+                locfn_list.append(fn)
         self._locfn_list = locfn_list
         self._interval = interval
         self._n = len(locfn_list)

From 497786997b20687fd596833b199515c13195cad8 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 9 Jan 2024 16:06:07 +0900
Subject: [PATCH 170/337] Remove mistakenly added empty file

---
 config/env/20240109-isolatation.toml | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 config/env/20240109-isolatation.toml

diff --git a/config/env/20240109-isolatation.toml b/config/env/20240109-isolatation.toml
deleted file mode 100644
index e69de29b..00000000

From 6238dc48e1c21f251fd928c42e8d7d5a651c34ba Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 9 Jan 2024 16:47:35 +0900
Subject: [PATCH 171/337] Tweak on log

---
 src/emevo/exp_utils.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 05b9ebac..47bc72d1 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -235,7 +235,7 @@ class LogMode(str, enum.Enum):
 
 
 def _default_dropped_keys() -> list[str]:
-    return ["slots", "dead", "parents"]
+    return ["dead", "parents"]
 
 
 @dataclasses.dataclass
@@ -275,6 +275,7 @@ def _save_log(self) -> None:
         log_dict = dataclasses.asdict(all_log)
         for dropped_key in self.dropped_keys:
             del log_dict[dropped_key]
+
         pq.write_table(
             pa.Table.from_pydict(log_dict),
             self.logdir.joinpath(f"log-{self._log_index}.parquet"),

From d376c4ca47dbc4f9966f9092831f9765ad88a87f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 9 Jan 2024 17:56:26 +0900
Subject: [PATCH 172/337] Tweak on isolation

---
 config/env/20240109-isolation.toml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/config/env/20240109-isolation.toml b/config/env/20240109-isolation.toml
index 3c8b4e7c..817182c1 100644
--- a/config/env/20240109-isolation.toml
+++ b/config/env/20240109-isolation.toml
@@ -1,7 +1,7 @@
 n_initial_agents = 20
 n_max_agents = 120
-n_max_foods = 50
-food_num_fn = ["logistic", 20, 0.01, 50]
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
 food_loc_fn = "gaussian-mixture"
 agent_loc_fn = "uniform"
 xlim = [0.0, 480.0]

From 0b3604ce5d7c1f742292f17186356effe2144991 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 9 Jan 2024 18:23:46 +0900
Subject: [PATCH 173/337] Circle env

---
 config/env/20240109-circle-2seasons.toml | 35 ++++++++++++++++++++++++
 config/env/20240109-circle.toml          | 30 ++++++++++++++++++++
 2 files changed, 65 insertions(+)
 create mode 100644 config/env/20240109-circle-2seasons.toml
 create mode 100644 config/env/20240109-circle.toml

diff --git a/config/env/20240109-circle-2seasons.toml b/config/env/20240109-circle-2seasons.toml
new file mode 100644
index 00000000..d9d5ec05
--- /dev/null
+++ b/config/env/20240109-circle-2seasons.toml
@@ -0,0 +1,35 @@
+n_initial_agents = 20
+n_max_agents = 120
+n_max_foods = 50
+food_num_fn = ["logistic", 20, 0.01, 50]
+food_loc_fn = [
+   "switching",
+   100,
+   ["gaussian", [240, 80], [40, 40]],
+   ["gaussian", [240, 400], [40, 40]]
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 480.0]
+env_shape = "circle"
+env_radius = 240
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 4e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file
diff --git a/config/env/20240109-circle.toml b/config/env/20240109-circle.toml
new file mode 100644
index 00000000..040e6ae5
--- /dev/null
+++ b/config/env/20240109-circle.toml
@@ -0,0 +1,30 @@
+n_initial_agents = 20
+n_max_agents = 120
+n_max_foods = 50
+food_num_fn = ["logistic", 20, 0.01, 50]
+food_loc_fn = ["gaussian", [240, 240], [40, 40]]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 480.0]
+env_shape = "circle"
+env_radius = 240
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 4e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From f455a0adf78abfffa853574b9fe21ffa2efcab55 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 9 Jan 2024 19:02:25 +0900
Subject: [PATCH 174/337] Fix interval of saving states

---
 experiments/cf_asexual_evo.py | 1 +
 src/emevo/exp_utils.py        | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index fa950d1f..4aa0fb54 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -483,6 +483,7 @@ def replay(
         env_state = dataclasses.replace(env_state, physics=phys)
         visualizer.render(env_state)
         visualizer.show()
+    visualizer.close()
 
 
 if __name__ == "__main__":
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 47bc72d1..52e964af 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -290,7 +290,7 @@ def push_physstate(self, phys_state: SavedPhysicsState) -> None:
 
         self._physstate_list.append(phys_state)
 
-        if len(self._physstate_list) % self.savestate_interval != 0:
+        if len(self._physstate_list) % self.savestate_interval == 0:
             self._save_physstate()
 
     def _save_physstate(self) -> None:

From 39b7219b514646f4b80716c364d60ac15538ddc2 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 9 Jan 2024 19:19:03 +0900
Subject: [PATCH 175/337] env override

---
 experiments/cf_asexual_evo.py | 2 ++
 src/emevo/exp_utils.py        | 6 ++++++
 2 files changed, 8 insertions(+)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 4aa0fb54..b8c516d8 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -361,6 +361,7 @@ def evolve(
     cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
     bdconfig_path: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
     gopsconfig_path: Path = here.joinpath("../config/gops/20231220-mutation-01.toml"),
+    env_override: str = "",
     birth_override: str = "",
     hazard_override: str = "",
     reward_fn: RewardKind = RewardKind.LINEAR,
@@ -379,6 +380,7 @@ def evolve(
         gopsconfig = toml.from_toml(GopsConfig, f.read())
 
     # Apply overrides
+    cfconfig.apply_override(env_override)
     bdconfig.apply_birth_override(birth_override)
     bdconfig.apply_hazard_override(hazard_override)
 
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 52e964af..76e14e07 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -63,6 +63,12 @@ class CfConfig:
     n_physics_iter: int = 5
     max_place_attempts: int = 10
 
+    def apply_override(self, override: str) -> None:
+        if 0 < len(override):
+            override_dict = json.loads(override)
+            for key, value in override_dict.items():
+                setattr(self, key, value)
+
 
 def _load_cls(cls_path: str) -> Type:
     try:

From 6b9c0420630762c60d87a337fe89143800fc1c1e Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 10 Jan 2024 14:56:30 +0900
Subject: [PATCH 176/337] Scheduled

---
 config/env/20240109-two-seasons.toml   | 11 +++++++-
 config/env/20240110-2seasons-100.toml  | 39 ++++++++++++++++++++++++++
 config/env/20240110-2seasons-1000.toml | 39 ++++++++++++++++++++++++++
 src/emevo/environments/env_utils.py    | 13 +++++++++
 4 files changed, 101 insertions(+), 1 deletion(-)
 create mode 100644 config/env/20240110-2seasons-100.toml
 create mode 100644 config/env/20240110-2seasons-1000.toml

diff --git a/config/env/20240109-two-seasons.toml b/config/env/20240109-two-seasons.toml
index e6258e81..5a609fe3 100644
--- a/config/env/20240109-two-seasons.toml
+++ b/config/env/20240109-two-seasons.toml
@@ -2,7 +2,16 @@ n_initial_agents = 20
 n_max_agents = 120
 n_max_foods = 50
 food_num_fn = ["logistic", 20, 0.01, 50]
-food_loc_fn = "switching"
+food_loc_fn = [
+   "scheduled",
+   10240,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["switching",
+       10,
+       ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+   ]
+]
 agent_loc_fn = "uniform"
 xlim = [0.0, 480.0]
 ylim = [0.0, 360.0]
diff --git a/config/env/20240110-2seasons-100.toml b/config/env/20240110-2seasons-100.toml
new file mode 100644
index 00000000..ec00edb5
--- /dev/null
+++ b/config/env/20240110-2seasons-100.toml
@@ -0,0 +1,39 @@
+n_initial_agents = 20
+n_max_agents = 120
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 50]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["switching",
+       100,
+       ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+   ]
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 100.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
+obstacles = "none"
\ No newline at end of file
diff --git a/config/env/20240110-2seasons-1000.toml b/config/env/20240110-2seasons-1000.toml
new file mode 100644
index 00000000..36be426e
--- /dev/null
+++ b/config/env/20240110-2seasons-1000.toml
@@ -0,0 +1,39 @@
+n_initial_agents = 20
+n_max_agents = 120
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 50]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["switching",
+       1000,
+       ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+   ]
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 100.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
+obstacles = "none"
\ No newline at end of file
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index 67539bfb..85834462 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -190,6 +190,7 @@ class Locating(str, enum.Enum):
     GAUSSIAN = "gaussian"
     GAUSSIAN_MIXTURE = "gaussian-mixture"
     PERIODIC = "periodic"
+    SCHEDULED = "scheduled"
     SWITCHING = "switching"
     UNIFORM = "uniform"
 
@@ -206,6 +207,8 @@ def __call__(self, *args: Any, **kwargs: Any) -> tuple[LocatingFn, LocatingState
             return LocPeriodic(*args, **kwargs), state
         elif self is Locating.UNIFORM:
             return loc_uniform(*args, **kwargs), state
+        elif self is Locating.SCHEDULED:
+            return LocScheduled(*args, **kwargs), state
         elif self is Locating.SWITCHING:
             return LocSwitching(*args, **kwargs), state
         else:
@@ -252,6 +255,8 @@ def __call__(self, _: chex.PRNGKey, state: LocatingState) -> jax.Array:
 
 
 class LocSwitching:
+    """Branching based on how many foods are produced."""
+
     def __init__(
         self,
         interval: int,
@@ -275,6 +280,14 @@ def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
         return jax.lax.switch(index, self._locfn_list, key, state)
 
 
+class LocScheduled(LocSwitching):
+    """Branching based on steps."""
+
+    def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
+        index = jnp.fmin(state.n_trial // self._interval, self._n)
+        return jax.lax.switch(index, self._locfn_list, key, state)
+
+
 def first_true(boolean_array: jax.Array) -> jax.Array:
     return jnp.logical_and(boolean_array, jnp.cumsum(boolean_array) == 1)
 

From 45cf8709892903f8797519400b8e4ab3b40f0181 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 10 Jan 2024 14:57:26 +0900
Subject: [PATCH 177/337] 60 foods

---
 config/env/20240110-2seasons-100.toml  | 2 +-
 config/env/20240110-2seasons-1000.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/config/env/20240110-2seasons-100.toml b/config/env/20240110-2seasons-100.toml
index ec00edb5..c38a482e 100644
--- a/config/env/20240110-2seasons-100.toml
+++ b/config/env/20240110-2seasons-100.toml
@@ -1,7 +1,7 @@
 n_initial_agents = 20
 n_max_agents = 120
 n_max_foods = 60
-food_num_fn = ["logistic", 20, 0.01, 50]
+food_num_fn = ["logistic", 20, 0.01, 60]
 food_loc_fn = [
    "scheduled",
    1024000,
diff --git a/config/env/20240110-2seasons-1000.toml b/config/env/20240110-2seasons-1000.toml
index 36be426e..14badb56 100644
--- a/config/env/20240110-2seasons-1000.toml
+++ b/config/env/20240110-2seasons-1000.toml
@@ -1,7 +1,7 @@
 n_initial_agents = 20
 n_max_agents = 120
 n_max_foods = 60
-food_num_fn = ["logistic", 20, 0.01, 50]
+food_num_fn = ["logistic", 20, 0.01, 60]
 food_loc_fn = [
    "scheduled",
    1024000,

From bbbb5aa61ff67e3707ac55497eff2dda9429b3e5 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 10 Jan 2024 17:36:34 +0900
Subject: [PATCH 178/337] Less foods

---
 config/env/20240110-less-foods.toml | 37 ++++++++++++++
 src/emevo/environments/env_utils.py | 75 ++++++++++++++++++++++-------
 2 files changed, 94 insertions(+), 18 deletions(-)
 create mode 100644 config/env/20240110-less-foods.toml

diff --git a/config/env/20240110-less-foods.toml b/config/env/20240110-less-foods.toml
new file mode 100644
index 00000000..ae09c174
--- /dev/null
+++ b/config/env/20240110-less-foods.toml
@@ -0,0 +1,37 @@
+n_initial_agents = 20
+n_max_agents = 120
+n_max_foods = 60
+food_num_fn = [
+   "scheduled",
+   2024000,
+   ["logistic", 20, 0.01, 60],
+   ["logistic", 20, 0.01, 50],
+   ["logistic", 20, 0.01, 40],
+   ["logistic", 20, 0.01, 30]
+]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 100.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
+obstacles = "none"
\ No newline at end of file
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index 85834462..ba13a6be 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -20,16 +20,28 @@
 class FoodNumState:
     current: jax.Array
     internal: jax.Array
+    n_called: jax.Array
 
     def appears(self) -> jax.Array:
         return (self.internal - self.current) >= 1.0
 
     def eaten(self, n: int | jax.Array) -> Self:
-        return FoodNumState(current=self.current - n, internal=self.internal - n)
+        return FoodNumState(
+            current=self.current - n,
+            internal=self.internal - n,
+            n_called=self.n_called,
+        )
 
     def recover(self, n: int | jax.Array = 1) -> Self:
         return dataclasses.replace(self, current=self.current + n)
 
+    def _update(self, internal: jax.Array) -> Self:
+        return FoodNumState(
+            current=self.current,
+            internal=internal,
+            n_called=self.n_called + 1,
+        )
+
 
 class ReprNumFn(Protocol):
     initial: int
@@ -44,10 +56,7 @@ class ReprNumConstant:
 
     def __call__(self, state: FoodNumState) -> FoodNumState:
         # Do nothing here
-        return dataclasses.replace(
-            state,
-            internal=jnp.array(self.initial, dtype=jnp.float32),
-        )
+        return state._update(jnp.array(self.initial, dtype=jnp.float32))
 
 
 @dataclasses.dataclass(frozen=True)
@@ -58,8 +67,8 @@ class ReprNumLinear:
     def __call__(self, state: FoodNumState) -> FoodNumState:
         # Increase the number of foods by dn_dt
         internal = jnp.fmax(state.current, state.internal)
-        internal = jnp.clip(internal + self.dn_dt, a_max=float(self.initial))
-        return dataclasses.replace(state, internal=internal)
+        max_value = jnp.array(self.initial, dtype=jnp.float32)
+        return state._update(jnp.clip(internal + self.dn_dt, a_max=max_value))
 
 
 @dataclasses.dataclass(frozen=True)
@@ -71,7 +80,37 @@ class ReprNumLogistic:
     def __call__(self, state: FoodNumState) -> FoodNumState:
         internal = jnp.fmax(state.current, state.internal)
         dn_dt = self.growth_rate * internal * (1 - internal / self.capacity)
-        return dataclasses.replace(state, internal=internal + dn_dt)
+        return state._update(internal + dn_dt)
+
+
+class ReprNumScheduled:
+    """Branching based on steps."""
+
+    def __init__(
+        self,
+        interval: int,
+        *num_fns: tuple[str, ...] | ReprNumFn,
+    ) -> None:
+        numfn_list = []
+        for fn_or_base in num_fns:
+            if callable(fn_or_base):
+                numfn_list.append(fn_or_base)
+            else:
+                name, *args = fn_or_base
+                fn, state = ReprNum(name)(*args)
+                del state
+                numfn_list.append(fn)
+        self._numfn_list = numfn_list
+        self._interval = interval
+        self._n = len(numfn_list)
+
+    @property
+    def initial(self) -> int:
+        return self._numfn_list[0].initial
+
+    def __call__(self, state: FoodNumState) -> FoodNumState:
+        index = jnp.fmin(state.n_called // self._interval, self._n)
+        return jax.lax.switch(index, self._numfn_list, state)
 
 
 class ReprNum(str, enum.Enum):
@@ -80,26 +119,26 @@ class ReprNum(str, enum.Enum):
     CONSTANT = "constant"
     LINEAR = "linear"
     LOGISTIC = "logistic"
+    SCHEDULED = "scheduled"
 
     def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn, FoodNumState]:
-        if len(args) > 0:
-            initial = args[0]
-        elif "initial" in kwargs:
-            initial = kwargs["initial"]
-        else:
-            raise ValueError("'initial' is required for all ReprNum functions")
-        state = FoodNumState(  # type: ignore
-            current=jnp.array(int(initial), dtype=jnp.int32),
-            internal=jnp.array(float(initial), dtype=jnp.float32),
-        )
         if self is ReprNum.CONSTANT:
             fn = ReprNumConstant(*args, **kwargs)
         elif self is ReprNum.LINEAR:
             fn = ReprNumLinear(*args, **kwargs)
         elif self is ReprNum.LOGISTIC:
             fn = ReprNumLogistic(*args, **kwargs)
+        elif self is ReprNum.SCHEDULED:
+            fn = ReprNumScheduled(*args, **kwargs)
         else:
             raise AssertionError("Unreachable")
+
+        initial = fn.initial
+        state = FoodNumState(
+            current=jnp.array(int(initial), dtype=jnp.int32),
+            internal=jnp.array(float(initial), dtype=jnp.float32),
+            n_called=jnp.array(1, dtype=jnp.int32),
+        )
         return cast(ReprNumFn, fn), state
 
 

From c43d456dd04080aa9528c4f357c11d92184435ee Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 11 Jan 2024 00:58:31 +0900
Subject: [PATCH 179/337] ReprNum/LocScheduled now support multiple bins

---
 src/emevo/environments/env_utils.py | 35 ++++++++++++++++++++++++-----
 1 file changed, 29 insertions(+), 6 deletions(-)

diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index ba13a6be..d0b1b105 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -88,7 +88,7 @@ class ReprNumScheduled:
 
     def __init__(
         self,
-        interval: int,
+        intervals: int | list[int],
         *num_fns: tuple[str, ...] | ReprNumFn,
     ) -> None:
         numfn_list = []
@@ -101,15 +101,17 @@ def __init__(
                 del state
                 numfn_list.append(fn)
         self._numfn_list = numfn_list
-        self._interval = interval
-        self._n = len(numfn_list)
+        if isinstance(int, intervals):
+            self._intervals = jnp.array([intervals])
+        else:
+            self._intervals = jnp.array(intervals)
 
     @property
     def initial(self) -> int:
         return self._numfn_list[0].initial
 
     def __call__(self, state: FoodNumState) -> FoodNumState:
-        index = jnp.fmin(state.n_called // self._interval, self._n)
+        index = jnp.digitize(state.n_called, bins=self._intervals)
         return jax.lax.switch(index, self._numfn_list, state)
 
 
@@ -319,11 +321,32 @@ def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
         return jax.lax.switch(index, self._locfn_list, key, state)
 
 
-class LocScheduled(LocSwitching):
+class LocScheduled:
     """Branching based on steps."""
 
+    def __init__(
+        self,
+        intervals: int | list[int],
+        *loc_fns: tuple[str, ...] | LocatingFn,
+    ) -> None:
+        locfn_list = []
+        for fn_or_base in loc_fns:
+            if callable(fn_or_base):
+                locfn_list.append(fn_or_base)
+            else:
+                name, *args = fn_or_base
+                fn, state = Locating(name)(*args)
+                del state
+                locfn_list.append(fn)
+        self._locfn_list = locfn_list
+        if isinstance(int, intervals):
+            self._intervals = jnp.array([intervals])
+        else:
+            self._intervals = jnp.array(intervals)
+
+
     def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
-        index = jnp.fmin(state.n_trial // self._interval, self._n)
+        index = jnp.digitize(state.n_called, bins=self._intervals)
         return jax.lax.switch(index, self._locfn_list, key, state)
 
 

From 818eb01eed696dc46407b9256438376518d192d3 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 11 Jan 2024 13:00:42 +0900
Subject: [PATCH 180/337] Food Num/Loc is schedulable more flexibly

---
 config/env/20240110-less-foods.toml |  5 ++-
 src/emevo/environments/env_utils.py | 57 ++++++++++++-----------------
 2 files changed, 27 insertions(+), 35 deletions(-)

diff --git a/config/env/20240110-less-foods.toml b/config/env/20240110-less-foods.toml
index ae09c174..e5cabc6e 100644
--- a/config/env/20240110-less-foods.toml
+++ b/config/env/20240110-less-foods.toml
@@ -3,11 +3,12 @@ n_max_agents = 120
 n_max_foods = 60
 food_num_fn = [
    "scheduled",
-   2024000,
+   2048000,
    ["logistic", 20, 0.01, 60],
    ["logistic", 20, 0.01, 50],
    ["logistic", 20, 0.01, 40],
-   ["logistic", 20, 0.01, 30]
+   ["logistic", 20, 0.01, 30],
+   ["logistic", 20, 0.01, 40],
 ]
 food_loc_fn = "gaussian"
 agent_loc_fn = "uniform"
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index d0b1b105..3c47cbc5 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -3,6 +3,7 @@
 
 import dataclasses
 import enum
+from collections.abc import Iterable
 from typing import Any, Callable, Protocol, cast
 
 import chex
@@ -97,14 +98,12 @@ def __init__(
                 numfn_list.append(fn_or_base)
             else:
                 name, *args = fn_or_base
-                fn, state = ReprNum(name)(*args)
-                del state
+                fn, _ = ReprNum(name)(*args)
                 numfn_list.append(fn)
         self._numfn_list = numfn_list
-        if isinstance(int, intervals):
-            self._intervals = jnp.array([intervals])
-        else:
-            self._intervals = jnp.array(intervals)
+        if isinstance(intervals, int):
+            intervals = [intervals * (i + 1) for i in range(len(self._numfn_list))]
+        self._intervals = jnp.array(intervals, dtype=jnp.int32)
 
     @property
     def initial(self) -> int:
@@ -295,6 +294,18 @@ def __call__(self, _: chex.PRNGKey, state: LocatingState) -> jax.Array:
         return self._locations[state.n_trial % self._n]
 
 
+def _collect_loc_fns(fns: Iterable[tuple[str, ...] | LocatingFn]) -> list[LocatingFn]:
+    locfn_list = []
+    for fn_or_args in fns:
+        if callable(fn_or_args):
+            locfn_list.append(fn_or_args)
+        else:
+            name, *init_args = fn_or_args
+            fn, _ = Locating(name)(*init_args)
+            locfn_list.append(fn)
+    return locfn_list
+
+
 class LocSwitching:
     """Branching based on how many foods are produced."""
 
@@ -303,18 +314,9 @@ def __init__(
         interval: int,
         *loc_fns: tuple[str, ...] | LocatingFn,
     ) -> None:
-        locfn_list = []
-        for fn_or_base in loc_fns:
-            if callable(fn_or_base):
-                locfn_list.append(fn_or_base)
-            else:
-                name, *args = fn_or_base
-                fn, state = Locating(name)(*args)
-                del state
-                locfn_list.append(fn)
-        self._locfn_list = locfn_list
+        self._locfn_list = _collect_loc_fns(loc_fns)
         self._interval = interval
-        self._n = len(locfn_list)
+        self._n = len(self._locfn_list)
 
     def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
         index = (state.n_produced // self._interval) % self._n
@@ -329,24 +331,13 @@ def __init__(
         intervals: int | list[int],
         *loc_fns: tuple[str, ...] | LocatingFn,
     ) -> None:
-        locfn_list = []
-        for fn_or_base in loc_fns:
-            if callable(fn_or_base):
-                locfn_list.append(fn_or_base)
-            else:
-                name, *args = fn_or_base
-                fn, state = Locating(name)(*args)
-                del state
-                locfn_list.append(fn)
-        self._locfn_list = locfn_list
-        if isinstance(int, intervals):
-            self._intervals = jnp.array([intervals])
-        else:
-            self._intervals = jnp.array(intervals)
-
+        self._locfn_list = _collect_loc_fns(loc_fns)
+        if isinstance(intervals, int):
+            intervals = [intervals * (i + 1) for i in range(len(self._locfn_list))]
+        self._intervals = jnp.array(intervals, dtype=jnp.int32)
 
     def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
-        index = jnp.digitize(state.n_called, bins=self._intervals)
+        index = jnp.digitize(state.n_trial, bins=self._intervals)
         return jax.lax.switch(index, self._locfn_list, key, state)
 
 

From 73cdc1f806c34d3bdcbb54869907fcb4144d91cd Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 11 Jan 2024 13:19:38 +0900
Subject: [PATCH 181/337] iso-scheduled

---
 config/env/20240111-iso-scheduled.toml | 39 ++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 config/env/20240111-iso-scheduled.toml

diff --git a/config/env/20240111-iso-scheduled.toml b/config/env/20240111-iso-scheduled.toml
new file mode 100644
index 00000000..ea7764ba
--- /dev/null
+++ b/config/env/20240111-iso-scheduled.toml
@@ -0,0 +1,39 @@
+n_initial_agents = 20
+n_max_agents = 120
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["gaussian-mixture",
+       [0.5, 0.5],
+       [[360.0, 270.0], [120.0, 270.0]],
+       [[48.0, 36.0], [48.0, 36.0]],
+   ]
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 100.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
+obstacles = "center-half"
\ No newline at end of file

From 5d0d2be8c859ae30a546f7020da20b0109750625 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 11 Jan 2024 16:23:38 +0900
Subject: [PATCH 182/337] GopsConfig now requires init_std and init_mean

---
 config/gops/20231220-mutation-01.toml         | 11 --------
 ...-0401.toml => 20240111-mutation-0401.toml} |  2 ++
 experiments/cf_asexual_evo.py                 | 28 +++++++++++--------
 src/emevo/exp_utils.py                        |  2 ++
 src/emevo/reward_fn.py                        | 28 +++++++++++--------
 tests/test_config.py                          |  2 +-
 6 files changed, 39 insertions(+), 34 deletions(-)
 delete mode 100644 config/gops/20231220-mutation-01.toml
 rename config/gops/{20231231-mutation-0401.toml => 20240111-mutation-0401.toml} (86%)

diff --git a/config/gops/20231220-mutation-01.toml b/config/gops/20231220-mutation-01.toml
deleted file mode 100644
index b7140649..00000000
--- a/config/gops/20231220-mutation-01.toml
+++ /dev/null
@@ -1,11 +0,0 @@
-path = "emevo.genetic_ops.BernoulliMixtureMutation"
-
-[params]
-mutation_prob = 0.2
-
-[params.mutator]
-path = "emevo.genetic_ops.UniformMutation"
-
-[params.mutator.params]
-min_noise = -1.0
-max_noise = 1.0
diff --git a/config/gops/20231231-mutation-0401.toml b/config/gops/20240111-mutation-0401.toml
similarity index 86%
rename from config/gops/20231231-mutation-0401.toml
rename to config/gops/20240111-mutation-0401.toml
index 27ce123a..d245fc02 100644
--- a/config/gops/20231231-mutation-0401.toml
+++ b/config/gops/20240111-mutation-0401.toml
@@ -1,4 +1,6 @@
 path = "emevo.genetic_ops.BernoulliMixtureMutation"
+init_std = 0.1
+init_mean = 0.0
 
 [params]
 mutation_prob = 0.4
diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index b8c516d8..4af05973 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -360,7 +360,7 @@ def evolve(
     n_total_steps: int = 1024 * 10000,
     cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
     bdconfig_path: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
-    gopsconfig_path: Path = here.joinpath("../config/gops/20231220-mutation-01.toml"),
+    gopsconfig_path: Path = here.joinpath("../config/gops/20240111-mutation-0401.toml"),
     env_override: str = "",
     birth_override: str = "",
     hazard_override: str = "",
@@ -397,11 +397,13 @@ def evolve(
     key, reward_key = jax.random.split(jax.random.PRNGKey(seed))
     if reward_fn == RewardKind.LINEAR:
         reward_fn_instance = LinearReward(
-            reward_key,
-            cfconfig.n_max_agents,
-            4,
-            extract_reward_linear,
-            lambda w: {
+            key=reward_key,
+            n_agents=cfconfig.n_max_agents,
+            n_weights=4,
+            std=gopsconfig.init_std,
+            mean=gopsconfig.init_mean,
+            extractor=extract_reward_linear,
+            serializer=lambda w: {
                 "agent": slice_last(w, 0),
                 "food": slice_last(w, 1),
                 "wall": slice_last(w, 2),
@@ -410,11 +412,13 @@ def evolve(
         )
     elif reward_fn == RewardKind.SIGMOID:
         reward_fn_instance = SigmoidReward(
-            reward_key,
-            cfconfig.n_max_agents,
-            4,
-            extract_reward_sigmoid,
-            lambda w, alpha: {
+            key=reward_key,
+            n_agents=cfconfig.n_max_agents,
+            n_weights=4,
+            std=gopsconfig.init_std,
+            mean=gopsconfig.init_mean,
+            extractor=extract_reward_sigmoid,
+            serializer=lambda w, alpha: {
                 "w_agent": slice_last(w, 0),
                 "w_food": slice_last(w, 1),
                 "w_wall": slice_last(w, 2),
@@ -425,6 +429,8 @@ def evolve(
                 "alpha_action": slice_last(alpha, 3),
             },
         )
+        print(reward_fn_instance.alpha)
+        print(reward_fn_instance.weight)
     else:
         raise ValueError(f"Invalid reward_fn {reward_fn}")
 
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 76e14e07..3700c57e 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -116,6 +116,8 @@ def _resolve_cls(d: dict[str, Any]) -> GopsConfig:
 @dataclasses.dataclass(frozen=True)
 class GopsConfig:
     path: str
+    init_std: float
+    init_mean: float
     params: Dict[str, Union[float, Dict[str, float]]]
 
     def load_model(self) -> gops.Mutation | gops.Crossover:
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index dcee22ea..15fb4dab 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -39,47 +39,53 @@ def _item_or_np(array: jax.Array) -> float | NDArray:
 class LinearReward(RewardFn):
     weight: jax.Array
     extractor: Callable[..., jax.Array]
-    serialiser: Callable[[jax.Array], dict[str, jax.Array]]
+    serializer: Callable[[jax.Array], dict[str, jax.Array]]
 
     def __init__(
         self,
+        *,  # order of arguments are a bit confusing here...
         key: chex.PRNGKey,
         n_agents: int,
         n_weights: int,
+        std: float,
+        mean: float,
         extractor: Callable[..., jax.Array],
-        serialiser: Callable[[jax.Array], dict[str, jax.Array]],
+        serializer: Callable[[jax.Array], dict[str, jax.Array]],
     ) -> None:
-        self.weight = jax.random.normal(key, (n_agents, n_weights))
+        self.weight = jax.random.normal(key, (n_agents, n_weights)) * std + mean
         self.extractor = extractor
-        self.serialiser = serialiser
+        self.serializer = serializer
 
     def __call__(self, *args) -> jax.Array:
         extracted = self.extractor(*args)
         return jax.vmap(jnp.dot)(extracted, self.weight)
 
     def serialise(self) -> dict[str, float | NDArray]:
-        return jax.tree_map(_item_or_np, self.serialiser(self.weight))
+        return jax.tree_map(_item_or_np, self.serializer(self.weight))
 
 
 class SigmoidReward(RewardFn):
     weight: jax.Array
     alpha: jax.Array
     extractor: Callable[..., tuple[jax.Array, jax.Array]]
-    serialiser: Callable[[jax.Array, jax.Array], dict[str, jax.Array]]
+    serializer: Callable[[jax.Array, jax.Array], dict[str, jax.Array]]
 
     def __init__(
         self,
+        *,
         key: chex.PRNGKey,
         n_agents: int,
         n_weights: int,
+        std: float,
+        mean: float,
         extractor: Callable[..., tuple[jax.Array, jax.Array]],
-        serialiser: Callable[[jax.Array, jax.Array], dict[str, jax.Array]],
+        serializer: Callable[[jax.Array, jax.Array], dict[str, jax.Array]],
     ) -> None:
         k1, k2 = jax.random.split(key)
-        self.weight = jax.random.normal(k1, (n_agents, n_weights))
-        self.alpha = jax.random.normal(k2, (n_agents, n_weights))
+        self.weight = jax.random.normal(k1, (n_agents, n_weights)) * std + mean
+        self.alpha = jax.random.normal(k2, (n_agents, n_weights)) * std + mean
         self.extractor = extractor
-        self.serialiser = serialiser
+        self.serializer = serializer
 
     def __call__(self, *args) -> jax.Array:
         extracted, energy = self.extractor(*args)
@@ -88,7 +94,7 @@ def __call__(self, *args) -> jax.Array:
         return jax.vmap(jnp.dot)(filtered, self.weight)
 
     def serialise(self) -> dict[str, float | NDArray]:
-        return jax.tree_map(_item_or_np, self.serialiser(self.weight, self.alpha))
+        return jax.tree_map(_item_or_np, self.serializer(self.weight, self.alpha))
 
 
 def mutate_reward_fn(
diff --git a/tests/test_config.py b/tests/test_config.py
index 8dcaaab8..b7df4c35 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -22,7 +22,7 @@ def test_cfconfig() -> None:
 
 
 def test_gopsconfig() -> None:
-    with open("config/gops/20231220-mutation-01.toml") as f:
+    with open("config/gops/20240111-mutation-0401.toml") as f:
         gopsconfig = toml.from_toml(GopsConfig, f.read())
 
     mutation = gopsconfig.load_model()

From 85da4fd918d048feb2669705c45ffb11b247f5f1 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 11 Jan 2024 16:38:48 +0900
Subject: [PATCH 183/337] Square 150

---
 config/env/20240111-square-150.toml | 29 +++++++++++++++++++++++++++++
 experiments/cf_asexual_evo.py       |  2 ++
 2 files changed, 31 insertions(+)
 create mode 100644 config/env/20240111-square-150.toml

diff --git a/config/env/20240111-square-150.toml b/config/env/20240111-square-150.toml
new file mode 100644
index 00000000..6e69f8a3
--- /dev/null
+++ b/config/env/20240111-square-150.toml
@@ -0,0 +1,29 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 50
+food_num_fn = ["logistic", 20, 0.01, 50]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file
diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 4af05973..e0bd6d1f 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -471,10 +471,12 @@ def replay(
     start: int = 0,
     end: Optional[int] = None,
     cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
+    env_override: str = "",
 ) -> None:
     with cfconfig_path.open("r") as f:
         cfconfig = toml.from_toml(CfConfig, f.read())
     cfconfig.n_initial_agents = n_agents
+    cfconfig.apply_override(env_override)
     phys_state = SavedPhysicsState.load(physstate_path)
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
     env_state, _ = env.reset(jax.random.PRNGKey(0))

From cfb5ae6aea0694af3d8545a625999901879d9cff Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 12 Jan 2024 02:02:05 +0900
Subject: [PATCH 184/337] Clip reward fn

---
 .../gops/20240112-mutation-0401-clipped.toml  |  15 +
 notebooks/bd_rate.ipynb                       |   2 +-
 notebooks/reward_fn.ipynb                     | 262 ++++++++++++++++++
 src/emevo/genetic_ops.py                      |  20 +-
 4 files changed, 296 insertions(+), 3 deletions(-)
 create mode 100644 config/gops/20240112-mutation-0401-clipped.toml
 create mode 100644 notebooks/reward_fn.ipynb

diff --git a/config/gops/20240112-mutation-0401-clipped.toml b/config/gops/20240112-mutation-0401-clipped.toml
new file mode 100644
index 00000000..ca0fee16
--- /dev/null
+++ b/config/gops/20240112-mutation-0401-clipped.toml
@@ -0,0 +1,15 @@
+path = "emevo.genetic_ops.BernoulliMixtureMutation"
+init_std = 0.1
+init_mean = 0.0
+
+[params]
+mutation_prob = 0.4
+
+[params.mutator]
+path = "emevo.genetic_ops.UniformMutation"
+
+[params.mutator.params]
+min_noise = -0.1
+max_noise = 0.1
+clip_min = -1.0
+clip_max = 1.0
\ No newline at end of file
diff --git a/notebooks/bd_rate.ipynb b/notebooks/bd_rate.ipynb
index 0898c2df..386dc981 100644
--- a/notebooks/bd_rate.ipynb
+++ b/notebooks/bd_rate.ipynb
@@ -494,7 +494,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.6"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/reward_fn.ipynb b/notebooks/reward_fn.ipynb
new file mode 100644
index 00000000..090f7243
--- /dev/null
+++ b/notebooks/reward_fn.ipynb
@@ -0,0 +1,262 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "31f0ecac-d024-4106-8700-0f84004e753e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import dataclasses\n",
+    "from typing import Any, Literal\n",
+    "\n",
+    "import ipywidgets as widgets\n",
+    "import numpy as np\n",
+    "from emevo import birth_and_death as bd\n",
+    "from matplotlib import pyplot as plt\n",
+    "from matplotlib.figure import Figure\n",
+    "from matplotlib.lines import Line2D\n",
+    "from matplotlib.text import Text\n",
+    "from mpl_toolkits.mplot3d.art3d import Poly3DCollection\n",
+    "\n",
+    "from emevo.plotting import (\n",
+    "    vis_birth,\n",
+    "    vis_expected_n_children,\n",
+    "    vis_hazard,\n",
+    "    vis_lifetime,\n",
+    "    show_params_text,\n",
+    ")\n",
+    "\n",
+    "%matplotlib ipympl"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "9de733db-cd24-4a67-ae28-f2e3ce2af415",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_slider(\n",
+    "    vmin: float,\n",
+    "    vmax: float,\n",
+    "    logscale: bool = True,\n",
+    "    n_steps: int = 400,\n",
+    ") -> widgets.FloatSlider | widgets.FloatLogSlider:\n",
+    "    if logscale:\n",
+    "        logmin = np.log10(vmin)\n",
+    "        logmax = np.log10(vmax)\n",
+    "        logstep = (logmax - logmin) / n_steps\n",
+    "        return widgets.FloatLogSlider(\n",
+    "            min=logmin,\n",
+    "            max=logmax,\n",
+    "            step=logstep,\n",
+    "            value=10 ** ((logmax + logmin) / 2.0),\n",
+    "            base=10,\n",
+    "            readout_format=\".3e\",\n",
+    "        )\n",
+    "    else:\n",
+    "        return widgets.FloatSlider(\n",
+    "            min=vmin,\n",
+    "            max=vmax,\n",
+    "            step=(vmax - vmin) / n_steps,\n",
+    "            value=(vmax + vmin) / 2,\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "df0fe701-8b83-4a0c-86f9-6d241cd930ea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sigmoid_reward_widget(\n",
+    "    f,\n",
+    "    energy_max: float = 40.0,\n",
+    "    alpha_max: float = 2.0,\n",
+    "    alpha_min: float = -2.0,\n",
+    "    n_discr: int = 1000,\n",
+    ") -> widgets.VBox:\n",
+    "    fig = plt.figure(figsize=(6, 6))\n",
+    "    ax = fig.add_subplot(111)\n",
+    "    ax.set_title(\"Sigmoid reward_fn\")\n",
+    "\n",
+    "    @dataclasses.dataclass\n",
+    "    class State:\n",
+    "        line: Line2D | None = None\n",
+    "\n",
+    "    state = State()\n",
+    "\n",
+    "    def update_figure(alpha: float = 0.0):\n",
+    "        if  state.line is None:\n",
+    "            ax.grid(True, which=\"major\")\n",
+    "            ax.set_xlabel(\"Energy\", fontsize=12)\n",
+    "            ax.set_ylabel(\"Reward Coef\", fontsize=12)\n",
+    "            ax.set_ylim((0.0, 1.0))\n",
+    "        else:\n",
+    "            state.line.remove()\n",
+    "\n",
+    "        energy = np.linspace(0.0, energy_max, n_discr)\n",
+    "        state.line = ax.plot(energy, f(energy, alpha), color=\"xkcd:bluish purple\")[0]\n",
+    "        fig.canvas.draw()\n",
+    "        fig.canvas.flush_events()\n",
+    "\n",
+    "    interactive = widgets.interactive(update_figure, alpha=make_slider(-2.0, 2.0, logscale=False, n_steps=n_discr))\n",
+    "    return widgets.VBox([interactive])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "547967f9-2c4b-40bb-a244-fcad24150897",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.5"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "1 / (1.0 + np.exp(-0.0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "64594795-61ee-46f9-b8f0-35325a5e2f56",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6ba92f872e6a4971afd6ffeb06c35ccc",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=2.0, min=-2.0, step=0.004…"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7bbf3489745b4f6187be49a7ca6679db",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sigmoid_reward_widget(lambda e, a: 1 / (1.0 + np.exp(- e * a * 0.5)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "e7383410-789d-422e-a1bd-fdd92ba629e6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7a8a122e41304167bf8cca461242b6d0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=2.0, min=-2.0, step=0.004…"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2554b178c52d414c89dcf765d7014586",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAJYCAYAAAC+ZpjcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABCFklEQVR4nO3dd3RU5b7/8c8kpNBbGoQSQKQTEEgMEEQJRPQgxYKAAjmKV4ogORyKFwigGAUPF0UULJSroIgVD0VpgXCIIE3BIxx6T0KIBEwkCWT//vCXuY4J/ZlMJrxfa2Ut9jO7fL+zyeLDs/fssVmWZQkAAADGeLi6AAAAgJKGgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAWUACEhIRo4cKCry7iqBQsWyGaz6ciRI9dc1x36cRabzaZJkybd0Da//vqrnn76aQUFBclms+n55593Sm0Arh8BCyjGdu/erUceeUS1a9eWr6+vgoOD1blzZ82aNcvVpaEYefnll7VgwQINHjxYH3zwgZ588klXlwTc9myWZVmuLgJAQZs3b9a9996rWrVqacCAAQoKCtLx48f13Xff6eDBgzpw4IB93ezsbHl4eMjLy8uFFV/d5cuXlZubKx8fH9lstquuGxISoo4dO2rBggVFU1wxYrPZFBcXd0OzWHfffbdKlSqlTZs2Oa8wADeklKsLAFC4qVOnqmLFivr+++9VqVIlh9dSU1Mdln18fIqwspvj6ekpT09Ppx7j0qVLysvLk7e3t1OPcysyMzNVtmxZo/tMTU1V48aNje4TwK3hEiFQTB08eFBNmjQpEK4kKSAgwGG5sHuWfvzxR91zzz0qXbq0atSooZdeeknz588vcB9USEiI/vKXvyghIUGtW7dW6dKl1axZMyUkJEiSPv/8czVr1ky+vr5q1aqVdu7cWaCedevWKTIyUmXLllWlSpXUvXt3/fzzzw7rFHYPlmVZeumll1SjRg2VKVNG9957r3766afren+OHDkim82m1157TTNnzlS9evXk4+Ojf//735KkvXv36pFHHlGVKlXk6+ur1q1ba9myZfbtz507J09PT73xxhv2sbS0NHl4eKhq1ar64+T+4MGDFRQUZF9OTEzUo48+qlq1asnHx0c1a9bUyJEj9dtvvznUOHDgQJUrV04HDx7UAw88oPLly6tfv36Sfp91HDlypPz9/VW+fHk99NBDOnHixHX1ni8hIUE2m02HDx/W8uXLZbPZ7O9x/muffPKJpk6dqho1asjX11edOnVymP0E4BzMYAHFVO3atZWUlKQ9e/aoadOmN7TtyZMnde+998pms2ncuHEqW7as3nvvvSvOdB04cEB9+/bVf/3Xf+mJJ57Qa6+9pm7dumnOnDl64YUXNGTIEElSfHy8HnvsMe3bt08eHr///2zNmjXq2rWr6tatq0mTJum3337TrFmz1K5dO+3YsUMhISFXrHPixIl66aWX9MADD+iBBx7Qjh071KVLF+Xk5Fx3r/Pnz9fFixf1zDPPyMfHR1WqVNFPP/2kdu3aKTg4WGPHjlXZsmX1ySefqEePHvrss8/Us2dPVapUSU2bNtXGjRs1fPhwSdKmTZtks9mUnp6uf//732rSpImk3wNVZGSk/ZhLly5VVlaWBg8erKpVq2rr1q2aNWuWTpw4oaVLlzrUd+nSJUVHR6t9+/Z67bXXVKZMGUnS008/rQ8//FB9+/ZV27ZttW7dOj344IPX3bckNWrUSB988IFGjhypGjVq6G9/+5skyd/f3x5kX3nlFXl4eGjUqFHKyMjQtGnT1K9fP23ZsuWGjgXgBlkAiqVvv/3W8vT0tDw9Pa2IiAhr9OjR1jfffGPl5OQUWLd27drWgAED7MvPPfecZbPZrJ07d9rHzp49a1WpUsWSZB0+fNhhW0nW5s2b7WPffPONJckqXbq0dfToUfv43LlzLUnW+vXr7WMtWrSwAgICrLNnz9rHfvjhB8vDw8Pq37+/fWz+/PkOx05NTbW8vb2tBx980MrLy7Ov98ILL1iSHPopzOHDhy1JVoUKFazU1FSH1zp16mQ1a9bMunjxon0sLy/Patu2rVW/fn372NChQ63AwED7cmxsrNWhQwcrICDAevvtt+3vm81ms15//XX7ellZWQXqiY+Pt2w2m8P7NWDAAEuSNXbsWId1d+3aZUmyhgwZ4jDet29fS5IVFxd31d7/rHbt2taDDz7oMLZ+/XpLktWoUSMrOzvbPv76669bkqzdu3ff0DEA3BguEQLFVOfOnZWUlKSHHnpIP/zwg6ZNm6bo6GgFBwc7XOoqzKpVqxQREaEWLVrYx6pUqWK/PPVnjRs3VkREhH05PDxcknTfffepVq1aBcYPHTokSTp9+rR27dqlgQMHqkqVKvb1mjdvrs6dO2vFihVXrHHNmjXKycnRc88953DT+40+YuDhhx+Wv7+/fTk9PV3r1q3TY489pgsXLigtLU1paWk6e/asoqOjtX//fp08eVKSFBkZqZSUFO3bt0/S7zNVHTp0UGRkpBITEyX9PqtlWZbDDFbp0qXtf87MzFRaWpratm0ry7IKvYQ6ePBgh+X89yV/5uxme78eMTExDvek5feRfw4BOAcBCyjG2rRpo88//1y//PKLtm7dqnHjxunChQt65JFH7PcaFebo0aO64447CowXNibJIURJUsWKFSVJNWvWLHT8l19+sR9Hkho0aFBgn40aNVJaWpoyMzOvWKMk1a9f32Hc399flStXLnSbwtSpU8dh+cCBA7IsSxMmTJC/v7/DT1xcnKT/+5BAfthITExUZmamdu7cqcjISHXo0MEesBITE1WhQgWFhobaj3Hs2DF7qCxXrpz8/f11zz33SJIyMjIc6ilVqpRq1KhRoHcPDw/Vq1fPYbyw9/FW/fnc5r+3+ecQgHNwDxbgBry9vdWmTRu1adNGd955p2JiYrR06VJ7YLhVV/p035XGrWL0dJc/ziZJUl5eniRp1KhRio6OLnSb/KBZvXp11alTRxs3blRISIgsy1JERIT8/f01YsQIHT16VImJiWrbtq39nrPLly+rc+fOSk9P15gxY9SwYUOVLVtWJ0+e1MCBA+3Hz+fj42Pf1hXc4RwCJREBC3AzrVu3lvT75bkrqV27dqGfFDP96bHatWtLkv0S2x/t3btXfn5+V3wkQf62+/fvV926de3jZ86cuaXZlfx9eXl5KSoq6prrR0ZGauPGjapTp45atGih8uXLKzQ0VBUrVtSqVau0Y8cOTZ482b7+7t279Z///EcLFy5U//797eOrV6++7hpr166tvLw8HTx40GHWqrD3EYB74hIhUEytX7++0FmG/Pt3rnY5KTo6WklJSdq1a5d9LD09XYsWLTJaY7Vq1dSiRQstXLhQ586ds4/v2bNH3377rR544IErbhsVFSUvLy/NmjXLoc+ZM2feUk0BAQHq2LGj5s6dW2gIPXPmjMNyZGSkjhw5oiVLltgvGXp4eKht27aaMWOGcnNzHe6/yp8R+mPNlmXp9ddfv+4au3btKkkOj4iQbr13AMUHM1hAMfXcc88pKytLPXv2VMOGDZWTk6PNmzdryZIlCgkJUUxMzBW3HT16tD788EN17txZzz33nP0xDbVq1VJ6evo1n6R+I6ZPn66uXbsqIiJCTz31lP0xDRUrVrzq08j9/f01atQoxcfH6y9/+YseeOAB7dy5UytXrpSfn98t1TR79my1b99ezZo106BBg1S3bl2lpKQoKSlJJ06c0A8//GBfNz887du3Ty+//LJ9vEOHDlq5cqV8fHzUpk0b+3jDhg1Vr149jRo1SidPnlSFChX02Wef3dCsW4sWLdSnTx+99dZbysjIUNu2bbV27VqeTwWUIAQsoJh67bXXtHTpUq1YsULvvPOOcnJyVKtWLQ0ZMkTjx48v9AGk+WrWrKn169dr+PDhevnll+Xv76+hQ4eqbNmyGj58uHx9fY3VGRUVpVWrVikuLk4TJ06Ul5eX7rnnHr366qsFbkD/s5deekm+vr6aM2eO1q9fr/DwcH377bc3/DyoP2vcuLG2bdumyZMna8GCBTp79qwCAgLUsmVLTZw40WHdBg0aKCAgQKmpqWrfvr19PD94hYWFOTw/zMvLS19//bWGDx+u+Ph4+fr6qmfPnho2bJjDjfDXMm/ePPn7+2vRokX68ssvdd9992n58uUFPlgAwD3xXYTAbeT555/X3Llz9euvvzr9a2sA4HbGPVhACfXnr205e/asPvjgA7Vv355wBQBOxiVCoISKiIhQx44d1ahRI6WkpOj999/X+fPnNWHCBFeXhutw+fLlAjfk/1m5cuVUrly5IqoIwI0gYAEl1AMPPKBPP/1U77zzjmw2m+666y69//776tChg6tLw3U4fvz4Ne9hi4uLu+oHCQC4jlveg7Vx40ZNnz5d27dv1+nTp/XFF1+oR48eV90mISFBsbGx+umnn1SzZk2NHz9eAwcOLJJ6AeBGXbx4UZs2bbrqOnXr1nV4hhiA4sMtZ7AyMzMVGhqqv/71r+rVq9c11z98+LAefPBBPfvss1q0aJHWrl2rp59+WtWqVbvik54BwJV8fX2v60GpAIont5zB+iObzXbNGawxY8Zo+fLl2rNnj33s8ccf17lz57Rq1aoiqBIAANxO3HIG60YlJSUV+J9gdHT0Vb+5Pjs7W9nZ2fblvLw8paenq2rVqkYf0ggAQElnWZYuXLig6tWru/S7OYvSbRGwkpOTFRgY6DAWGBio8+fP67fffivwZbGSFB8f7/D9YwAA4NYcP35cNWrUcHUZReK2CFg3Y9y4cYqNjbUvZ2RkqFatWjp8+LDKly9/y/u3LEtZv+Zq44aN6nBPB3mV8rrlfRYHuZfoyR3QU/FX0vqR6Mld5PfUqUsHeXt7G9nnhQsXVKdOHSP/frqL2yJgBQUFKSUlxWEsJSVFFSpUKHT2SpJ8fHwcvh4jX5UqVVShQgUjdeVWzFX5Sr6qFuwnL68S8ouZS0/ugJ6Kv5LWj0RP7iK/Jz8/cz3l7+d2usXmtrgQGhERobVr1zqMrV69WhERES6qCAAAlGRuGbB+/fVX7dq1S7t27ZL0+2MYdu3apWPHjkn6/fJe//797es/++yzOnTokEaPHq29e/fqrbfe0ieffKKRI0e6onwAAFDCuWXA2rZtm1q2bKmWLVtKkmJjY9WyZUtNnDhRknT69Gl72JKkOnXqaPny5Vq9erVCQ0P1j3/8Q++99x7PwAIAAE7hlvdgdezYUVd7fNeCBQsK3Wbnzp1OrAoAAOB3bjmDBQAAUJwRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGuW3Amj17tkJCQuTr66vw8HBt3br1quvPnDlTDRo0UOnSpVWzZk2NHDlSFy9eLKJqAQDA7cQtA9aSJUsUGxuruLg47dixQ6GhoYqOjlZqamqh6y9evFhjx45VXFycfv75Z73//vtasmSJXnjhhSKuHAAA3A7cMmDNmDFDgwYNUkxMjBo3bqw5c+aoTJkymjdvXqHrb968We3atVPfvn0VEhKiLl26qE+fPtec9QIAALgZpVxdwI3KycnR9u3bNW7cOPuYh4eHoqKilJSUVOg2bdu21YcffqitW7cqLCxMhw4d0ooVK/Tkk09e8TjZ2dnKzs62L58/f16SlJubq9zcXCO95O/H1P6KA3pyD/RU/JW0fiR6chfO6KkkvT/Xy2ZZluXqIm7EqVOnFBwcrM2bNysiIsI+Pnr0aG3YsEFbtmwpdLs33nhDo0aNkmVZunTpkp599lm9/fbbVzzOpEmTNHny5ALjixcvVpkyZW69EQAAbhNZWVnq27evMjIyVKFCBVeXUyTcbgbrZiQkJOjll1/WW2+9pfDwcB04cEAjRozQiy++qAkTJhS6zbhx4xQbG2tfPn/+vGrWrKkuXboY+8uRm5ur1atXq3PnzvLy8jKyT1ejJ/dAT8VfSetHoid34Yye8q8C3U7cLmD5+fnJ09NTKSkpDuMpKSkKCgoqdJsJEyboySef1NNPPy1JatasmTIzM/XMM8/ov//7v+XhUfBWNB8fH/n4+BQY9/LyMv5L5Ix9uho9uQd6Kv5KWj8SPbkLkz2VtPfmerjdTe7e3t5q1aqV1q5dax/Ly8vT2rVrHS4Z/lFWVlaBEOXp6SlJcrMrpAAAwA243QyWJMXGxmrAgAFq3bq1wsLCNHPmTGVmZiomJkaS1L9/fwUHBys+Pl6S1K1bN82YMUMtW7a0XyKcMGGCunXrZg9aAAAAprhlwOrdu7fOnDmjiRMnKjk5WS1atNCqVasUGBgoSTp27JjDjNX48eNls9k0fvx4nTx5Uv7+/urWrZumTp3qqhYAAEAJ5pYBS5KGDRumYcOGFfpaQkKCw3KpUqUUFxenuLi4IqgMAADc7tzuHiwAAIDijoAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGGY0YC1btkynTp0yuUsAAAC3YzRg9ezZUwkJCfblunXratmyZSYPYTd79myFhITI19dX4eHh2rp161XXP3funIYOHapq1arJx8dHd955p1asWOGU2gAAwO2tlMmdlS9fXufOnbMvHzlyRL/++qvJQ0iSlixZotjYWM2ZM0fh4eGaOXOmoqOjtW/fPgUEBBRYPycnR507d1ZAQIA+/fRTBQcH6+jRo6pUqZLx2gAAAIwGrLCwME2dOlUpKSmqWLGiJGnFihVKTk6+4jY2m00jR468oePMmDFDgwYNUkxMjCRpzpw5Wr58uebNm6exY8cWWH/evHlKT0/X5s2b5eXlJUkKCQm5oWMCAABcL6MB66233lL//v314osvSvo9PC1evFiLFy++4jY3GrBycnK0fft2jRs3zj7m4eGhqKgoJSUlFbrNsmXLFBERoaFDh+qrr76Sv7+/+vbtqzFjxsjT0/O6jw0AAHA9jAasO+64Q5s3b9bFixeVmpqqkJAQzZw5U927dzd2jLS0NF2+fFmBgYEO44GBgdq7d2+h2xw6dEjr1q1Tv379tGLFCh04cEBDhgxRbm6u4uLiCt0mOztb2dnZ9uXz589LknJzc5Wbm2ukl/z9mNpfcUBP7oGeir+S1o9ET+7CGT2VpPfnetksy7KctfPJkyfr4YcfVtOmTY3t89SpUwoODtbmzZsVERFhHx89erQ2bNigLVu2FNjmzjvv1MWLF3X48GH7jNWMGTM0ffp0nT59utDjTJo0SZMnTy4wvnjxYpUpU8ZQNwAAlHxZWVnq27evMjIyVKFCBVeXUySMzmD92R9nh06fPq3U1FTdcccdKlu27E3v08/PT56enkpJSXEYT0lJUVBQUKHbVKtWTV5eXg6XAxs1aqTk5GTl5OTI29u7wDbjxo1TbGysffn8+fOqWbOmunTpYuwvR25urlavXq3OnTvb7w1zd/TkHuip+Ctp/Uj05C6c0VP+VaDbiVMDliR99dVXGjNmjPbv3y9JWr16te677z6lpaWpc+fOiouLU48ePa57f97e3mrVqpXWrl1r3y4vL09r167VsGHDCt2mXbt2Wrx4sfLy8uTh8fuTKf7zn/+oWrVqhYYrSfLx8ZGPj0+BcS8vL+O/RM7Yp6vRk3ugp+KvpPUj0ZO7MNlTSXtvrodTn+T+9ddfq1evXvLz81NcXJz+eDXSz89PwcHBmj9//g3vNzY2Vu+++64WLlyon3/+WYMHD1ZmZqb9U4X9+/d3uAl+8ODBSk9P14gRI/Sf//xHy5cv18svv6yhQ4feepMAAAB/4tQZrClTpqhDhw5av369zp49q0mTJjm8HhERoblz597wfnv37q0zZ85o4sSJSk5OVosWLbRq1Sr7je/Hjh2zz1RJUs2aNfXNN99o5MiRat68uYKDgzVixAiNGTPmlvoDAAAojFMD1p49ezRjxowrvh4YGKjU1NSb2vewYcOueEnwj0+TzxcREaHvvvvupo4FAABwI5x6ibBMmTLKzMy84uuHDh1S1apVnVkCAABAkXNqwLr33nu1cOFCXbp0qcBrycnJevfdd9WlSxdnlgAAAFDknBqwpk6dqhMnTqhNmzaaO3eubDabvvnmG40fP17NmjWTZVlXfNAnAACAu3JqwGrQoIE2bdqkqlWrasKECbIsS9OnT9fLL7+sZs2aKTExke8EBAAAJY7Tn4PVpEkTrVmzRr/88osOHDigvLw81a1bV/7+/s4+NAAAgEs4PWDlq1y5stq0aVNUhwMAAHAZp14ilH5/PP7kyZMVFhamwMBABQYGKiwsTFOmTLktH50PAABKPqcGrFOnTqlly5aaPHmyfv31V7Vr107t2rVTZmamJk2apLvuuuuKX7YMAADgrpx6iXDMmDFKTk7WP//5Tz3wwAMOr61cuVKPPvqoxo4dq4ULFzqzDAAAgCLl1BmsVatW6fnnny8QriSpa9euGj58uFasWOHMEgAAAIqcUwNWZmam/fsBCxMUFHTVJ70DAAC4I6cGrMaNG+ujjz5STk5Ogddyc3P10UcfqXHjxs4sAQAAoMg5/R6s3r17KywsTEOGDNGdd94pSdq3b5/mzJmjH3/8UUuWLHFmCQAAAEXOqQHr0UcfVWZmpsaOHatnn31WNptNkmRZlgICAjRv3jw98sgjziwBAACgyDn9QaMDBw7UE088oW3btuno0aOSpNq1a6t169YqVarInnMKAABQZIok4ZQqVUp333237r777qI4HAAAgEsZv8n99OnTatiwoSZMmHDV9caPH69GjRopNTXVdAkAAAAuZTxgvf7660pPT9eYMWOuut6YMWOUnp6uWbNmmS4BAADApYwHrOXLl6tPnz4qV67cVdcrX768+vbtq2XLlpkuAQAAwKWMB6yDBw+qefPm17VukyZNdODAAdMlAAAAuJTxgOXp6Vnog0ULk5ubKw8Ppz7rFAAAoMgZTzf16tXTpk2brmvdf/3rX6pXr57pEgAAAFzKeMDq2bOnli5dqqSkpKuu99133+mTTz5Rz549TZcAAADgUsYDVmxsrGrUqKEuXbro1Vdf1cmTJx1eP3nypF599VV16dJFNWrU0MiRI02XAAAA4FLGA1b58uW1Zs0a1atXT+PGjVOtWrVUpUoV1a5dW1WqVFGtWrU0btw41alTR6tXr1aFChVMlwAAAOBSTnmSe926dbV9+3Z9+umnWrZsmfbu3avz58+rTp06atiwobp166ZHHnmEr8oBAAAlktMSjqenp3r37q3evXs76xAAAADFEs9IAAAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYZfUzDlClTbngbm82mCRMmmCwDAADApYwGrEmTJhUYs9lskiTLsgqMW5ZFwAIAACWO0UuEeXl5Dj/Hjx9Xs2bN1KdPH23dulUZGRnKyMjQli1b9Pjjjys0NFTHjx83WQIAAIDLOfUerKFDh6p+/fr68MMP1bp1a5UvX17ly5dXmzZttGjRItWrV09Dhw51ZgkAAABFzqkBa926dbrvvvuu+HqnTp20du1aZ5YAAABQ5JwasHx9fZWUlHTF1zdv3ixfX19nlgAAAFDknBqw+vXrp0WLFmn48OHav3+//d6s/fv367nnntPixYvVr18/Z5YAAABQ5Ix+ivDPXn31VaWlpenNN9/U7Nmz5eHxe57Ly8uTZVnq06ePXn31VWeWAAAAUOScGrC8vb31wQcf6O9//7tWrFiho0ePSpJq166trl27KjQ01JmHBwAAcAmnBaysrCw98cQTevjhh9WvXz81b97cWYcCAAAoVpx2D1aZMmW0Zs0aZWVlOesQAAAAxZJTb3Jv3779VT9FCAAAUBI5NWC9+eabSkxM1Pjx43XixAlnHgoAAKDYcGrACg0N1YkTJxQfH6/atWvLx8dHFSpUcPipWLGiM0sAAAAock79FOHDDz9s/7JnAACA24VTA9aCBQucuXsAAIBiyamXCAEAAG5HTp3BynfixAnt3LlTGRkZysvLK/B6//79i6IMAACAIuHUgHXx4kUNGDBAn332mfLy8mSz2WRZliQ53JtFwAIAACWJUy8RvvDCC/r88881depUJSQkyLIsLVy4UN9++639q3J++OEHZ5YAAABQ5JwasD799FPFxMRozJgxatKkiSQpODhYUVFR+uc//6lKlSpp9uzZziwBAACgyDk1YKWmpiosLEySVLp0aUlSZmam/fWHH35Yn3/+uTNLAAAAKHJODViBgYE6e/aspN+/m7By5crat2+f/fXz58/r4sWLziwBAACgyDn1Jvfw8HBt2rRJY8aMkSR169ZN06dPV7Vq1ZSXl6f/+Z//0d133+3MEgAAAIqcU2ewhg8frrp16yo7O1uS9OKLL6pSpUp68sknNWDAAFWsWFFvvPGGM0sAAAAock6dwWrfvr3at29vX65Zs6Z+/vln7d69W56enmrYsKFKlSqSR3EBAAAUmSJPNx4eHgoNDS3qwwIAABQZpwas6tWrKzIy0v5DsAIAALcDpwas7t27a9OmTfr0008lSRUqVFDbtm3VoUMHRUZGqk2bNvLy8nJmCQAAAEXOqQHr7bffliT98ssvSkxMVGJiojZt2qSJEyfq0qVL8vHxUXh4uNavX+/MMgAAAIpUkdyDVblyZT300EN66KGHdPz4ca1cuVIzZszQf/7zH23cuLEoSgAAACgyTg9YP//8s332KjExUcePH1fFihUVERGhmJgYRUZGOrsEAACAIuXUgOXv76/09HQFBAQoMjJSf/vb3+w3u9tsNmceGgAAwGWc+qDRs2fPymazqWHDhmrUqJEaNWqk+vXrE64AAECJ5tQZrDNnzmjTpk1KTEzUqlWrFB8fL0lq0aKF/dEN7du3l5+fnzPLAAAAKFJODVhVq1ZV9+7d1b17d0lSVlaWkpKSlJiYqE8++UQzZ86UzWbTpUuXnFkGAABAkSqyJ7nv379fiYmJ2rhxoxITE3X48GFJv9+nBQAAUJI4NWC9+eab2rhxozZt2qSUlBRZlqU6deooMjJSL7zwgiIjI3XnnXc6swQAAIAi59SA9fzzz6tp06Z6+OGH7fdcVatWzZmHBAAAcDmnBqyzZ8+qYsWKzjwEAABAsePUxzT8MVydPn1aP/zwgzIzM515SAAAAJdzasCSpK+++koNGzZUjRo1dNddd2nLli2SpLS0NLVs2VJffvmls0sAAAAoUk4NWF9//bV69eolPz8/xcXFybIs+2t+fn4KDg7W/PnznVkCAABAkXNqwJoyZYo6dOigTZs2aejQoQVej4iI0M6dO51ZAgAAQJFzasDas2ePHnvssSu+HhgYqNTUVGeWAAAAUOScGrDKlClz1ZvaDx06pKpVqzqzBAAAgCLn1IB17733auHChYV+FU5ycrLeffdddenSxZklAAAAFDmnBqypU6fqxIkTatOmjebOnSubzaZvvvlG48ePV7NmzWRZluLi4pxZAgAAQJFzasBq0KCBNm3apKpVq2rChAmyLEvTp0/Xyy+/rGbNmikxMVEhISHOLAEAAKDIOf05WE2aNNGaNWuUlpamLVu2KCkpSSkpKVq3bp0aNWrk8OiGGzF79myFhITI19dX4eHh2rp163Vt9/HHH8tms6lHjx43dVwAAIBrcXrAyle5cmW1adNG4eHh8vf3V05Ojt555x01aNDghve1ZMkSxcbGKi4uTjt27FBoaKiio6Ov+YnEI0eOaNSoUYqMjLzZNgAAAK7JKQErJydHn376qV599VW98847OnXqlP21rKwsTZs2TSEhIXr22WdvagZrxowZGjRokGJiYtS4cWPNmTNHZcqU0bx58664zeXLl9WvXz9NnjxZdevWvam+AAAArofxL3s+deqUOnbsqIMHD9rDU+nSpbVs2TJ5e3urb9++OnnypMLCwjRr1iz16tXrhvafk5Oj7du3a9y4cfYxDw8PRUVFKSkp6YrbTZkyRQEBAXrqqaeUmJh4zeNkZ2crOzvbvnz+/HlJUm5urnJzc2+o5ivJ34+p/RUH9OQe6Kn4K2n9SPTkLpzRU0l6f66XzbrZm6CuICYmRh9++KH9Utzhw4c1ZcoUlStXTmlpaWrSpIni4+N1zz333NT+T506peDgYG3evFkRERH28dGjR2vDhg327zr8o02bNunxxx/Xrl275Ofnp4EDB+rcuXNX/R7ESZMmafLkyQXGFy9erDJlytxU7QAA3I6ysrLUt29fZWRkqEKFCq4up0gYn8FavXq1YmJiFB8fbx8LCgrSo48+qgcffFBfffWVPDyK7NYvXbhwQU8++aTeffdd+fn5Xfd248aNU2xsrH35/Pnzqlmzprp06WLsL0dubq5Wr16tzp07y8vLy8g+XY2e3AM9FX8lrR+JntyFM3rKvwp0OzEesFJSUnT33Xc7jOUv//Wvf73lcOXn5ydPT0+lpKQUOG5QUFCB9Q8ePKgjR46oW7du9rG8vDxJUqlSpbRv3z7Vq1evwHY+Pj7y8fEpMO7l5WX8l8gZ+3Q1enIP9FT8lbR+JHpyFyZ7KmnvzfUwPpV0+fJl+fr6OozlL1esWPGW9+/t7a1WrVpp7dq19rG8vDytXbvW4ZJhvoYNG2r37t3atWuX/eehhx7Svffeq127dqlmzZq3XBMAAMAfGZ/Bkn5/HMKOHTvsyxkZGZKk/fv3q1KlSgXWv+uuu25o/7GxsRowYIBat26tsLAwzZw5U5mZmYqJiZEk9e/fX8HBwYqPj5evr6+aNm3qsH1+DX8eBwAAMMEpAWvChAmaMGFCgfEhQ4Y4LFuWJZvNpsuXL9/Q/nv37q0zZ85o4sSJSk5OVosWLbRq1SoFBgZKko4dO1ak93kBAAD8kfGANX/+fNO7LNSwYcM0bNiwQl9LSEi46rYLFiwwXxAAAMD/ZzxgDRgwwPQuAQAA3ArX0QAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGuW3Amj17tkJCQuTr66vw8HBt3br1iuu+++67ioyMVOXKlVW5cmVFRUVddX0AAIBb4ZYBa8mSJYqNjVVcXJx27Nih0NBQRUdHKzU1tdD1ExIS1KdPH61fv15JSUmqWbOmunTpopMnTxZx5QAA4HbglgFrxowZGjRokGJiYtS4cWPNmTNHZcqU0bx58wpdf9GiRRoyZIhatGihhg0b6r333lNeXp7Wrl1bxJUDAIDbgdsFrJycHG3fvl1RUVH2MQ8PD0VFRSkpKem69pGVlaXc3FxVqVLFWWUCAIDbWClXF3Cj0tLSdPnyZQUGBjqMBwYGau/evde1jzFjxqh69eoOIe3PsrOzlZ2dbV8+f/68JCk3N1e5ubk3UXlB+fsxtb/igJ7cAz0VfyWtH4me3IUzeipJ78/1slmWZbm6iBtx6tQpBQcHa/PmzYqIiLCPjx49Whs2bNCWLVuuuv0rr7yiadOmKSEhQc2bN7/iepMmTdLkyZMLjC9evFhlypS5+QYAALjNZGVlqW/fvsrIyFCFChVcXU6RcLsZLD8/P3l6eiolJcVhPCUlRUFBQVfd9rXXXtMrr7yiNWvWXDVcSdK4ceMUGxtrXz5//rz95nhTfzlyc3O1evVqde7cWV5eXkb26Wr05B7oqfgraf1I9OQunNFT/lWg24nbBSxvb2+1atVKa9euVY8ePSTJfsP6sGHDrrjdtGnTNHXqVH3zzTdq3br1NY/j4+MjHx+fAuNeXl7Gf4mcsU9Xoyf3QE/FX0nrR6Ind2Gyp5L23lwPtwtYkhQbG6sBAwaodevWCgsL08yZM5WZmamYmBhJUv/+/RUcHKz4+HhJ0quvvqqJEydq8eLFCgkJUXJysiSpXLlyKleunMv6AAAAJZNbBqzevXvrzJkzmjhxopKTk9WiRQutWrXKfuP7sWPH5OHxfx+QfPvtt5WTk6NHHnnEYT9xcXGaNGlSUZYOAABuA24ZsCRp2LBhV7wkmJCQ4LB85MgR5xcEAADw/7ndc7AAAACKOwIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGFuG7Bmz56tkJAQ+fr6Kjw8XFu3br3q+kuXLlXDhg3l6+urZs2aacWKFUVUKQAAuN24ZcBasmSJYmNjFRcXpx07dig0NFTR0dFKTU0tdP3NmzerT58+euqpp7Rz50716NFDPXr00J49e4q4cgAAcDtwy4A1Y8YMDRo0SDExMWrcuLHmzJmjMmXKaN68eYWu//rrr+v+++/X3//+dzVq1Egvvvii7rrrLr355ptFXDkAALgdlHJ1ATcqJydH27dv17hx4+xjHh4eioqKUlJSUqHbJCUlKTY21mEsOjpaX3755RWPk52drezsbPtyRkaGJCk9PV25ubm30MH/yc3NVVZWls6ePSsvLy8j+3Q1enIP9FT8lbR+JHpyF87o6cKFC5Iky7KM7M8duF3ASktL0+XLlxUYGOgwHhgYqL179xa6TXJycqHrJycnX/E48fHxmjx5coHxOnXq3ETVAADgwoULqlixoqvLKBJuF7CKyrhx4xxmvfLy8pSenq6qVavKZrMZOcb58+dVs2ZNHT9+XBUqVDCyT1ejJ/dAT8VfSetHoid34YyeLMvShQsXVL16dSP7cwduF7D8/Pzk6emplJQUh/GUlBQFBQUVuk1QUNANrS9JPj4+8vHxcRirVKnSzRV9DRUqVCgxv5j56Mk90FPxV9L6kejJXZju6XaZucrndje5e3t7q1WrVlq7dq19LC8vT2vXrlVERESh20RERDisL0mrV6++4voAAAC3wu1msCQpNjZWAwYMUOvWrRUWFqaZM2cqMzNTMTExkqT+/fsrODhY8fHxkqQRI0bonnvu0T/+8Q89+OCD+vjjj7Vt2za98847rmwDAACUUG4ZsHr37q0zZ85o4sSJSk5OVosWLbRq1Sr7jezHjh2Th8f/Tc61bdtWixcv1vjx4/XCCy+ofv36+vLLL9W0aVNXtSDp98uQcXFxBS5FujN6cg/0VPyVtH4kenIXJbEnV7BZt9NnJgEAAIqA292DBQAAUNwRsAAAAAwjYAEAABhGwAIAADCMgOVCs2fPVkhIiHx9fRUeHq6tW7e6uqSbNmnSJNlsNoefhg0burqsG7Jx40Z169ZN1atXl81mK/BdlZZlaeLEiapWrZpKly6tqKgo7d+/3zXFXodr9TNw4MAC5+z+++93TbHXKT4+Xm3atFH58uUVEBCgHj16aN++fQ7rXLx4UUOHDlXVqlVVrlw5PfzwwwUeNFycXE9PHTt2LHCunn32WRdVfHVvv/22mjdvbn9IZUREhFauXGl/3d3Oj3Ttntzp/FzJK6+8IpvNpueff94+5o7nqjghYLnIkiVLFBsbq7i4OO3YsUOhoaGKjo5Wamqqq0u7aU2aNNHp06ftP5s2bXJ1STckMzNToaGhmj17dqGvT5s2TW+88YbmzJmjLVu2qGzZsoqOjtbFixeLuNLrc61+JOn+++93OGcfffRREVZ44zZs2KChQ4fqu+++0+rVq5Wbm6suXbooMzPTvs7IkSP19ddfa+nSpdqwYYNOnTqlXr16ubDqq7ueniRp0KBBDudq2rRpLqr46mrUqKFXXnlF27dv17Zt23Tfffepe/fu+umnnyS53/mRrt2T5D7npzDff/+95s6dq+bNmzuMu+O5KlYsuERYWJg1dOhQ+/Lly5et6tWrW/Hx8S6s6ubFxcVZoaGhri7DGEnWF198YV/Oy8uzgoKCrOnTp9vHzp07Z/n4+FgfffSRCyq8MX/ux7Isa8CAAVb37t1dUo8pqampliRrw4YNlmX9fk68vLyspUuX2tf5+eefLUlWUlKSq8q8IX/uybIs65577rFGjBjhuqJuUeXKla333nuvRJyffPk9WZZ7n58LFy5Y9evXt1avXu3QR0k6V67CDJYL5OTkaPv27YqKirKPeXh4KCoqSklJSS6s7Nbs379f1atXV926ddWvXz8dO3bM1SUZc/jwYSUnJzucs4oVKyo8PNytz1lCQoICAgLUoEEDDR48WGfPnnV1STckIyNDklSlShVJ0vbt25Wbm+twnho2bKhatWq5zXn6c0/5Fi1aJD8/PzVt2lTjxo1TVlaWK8q7IZcvX9bHH3+szMxMRURElIjz8+ee8rnj+ZGkoUOH6sEHH3Q4J1LJ+F1yNbd8kru7S0tL0+XLl+1Pns8XGBiovXv3uqiqWxMeHq4FCxaoQYMGOn36tCZPnqzIyEjt2bNH5cuXd3V5tyw5OVmSCj1n+a+5m/vvv1+9evVSnTp1dPDgQb3wwgvq2rWrkpKS5Onp6eryrikvL0/PP/+82rVrZ/9WhuTkZHl7exf4YnZ3OU+F9SRJffv2Ve3atVW9enX9+OOPGjNmjPbt26fPP//chdVe2e7duxUREaGLFy+qXLly+uKLL9S4cWPt2rXLbc/PlXqS3O/85Pv444+1Y8cOff/99wVec/ffpeKAgAUjunbtav9z8+bNFR4ertq1a+uTTz7RU0895cLKcCWPP/64/c/NmjVT8+bNVa9ePSUkJKhTp04urOz6DB06VHv27HG7e/2u5ko9PfPMM/Y/N2vWTNWqVVOnTp108OBB1atXr6jLvKYGDRpo165dysjI0KeffqoBAwZow4YNri7rllypp8aNG7vd+ZGk48ePa8SIEVq9erV8fX1dXU6JxCVCF/Dz85Onp2eBT2OkpKQoKCjIRVWZValSJd155506cOCAq0sxIv+8lORzVrduXfn5+bnFORs2bJj++c9/av369apRo4Z9PCgoSDk5OTp37pzD+u5wnq7UU2HCw8MlqdieK29vb91xxx1q1aqV4uPjFRoaqtdff92tz8+VeipMcT8/0u+XAFNTU3XXXXepVKlSKlWqlDZs2KA33nhDpUqVUmBgoNueq+KCgOUC3t7eatWqldauXWsfy8vL09q1ax2u6buzX3/9VQcPHlS1atVcXYoRderUUVBQkMM5O3/+vLZs2VJiztmJEyd09uzZYn3OLMvSsGHD9MUXX2jdunWqU6eOw+utWrWSl5eXw3nat2+fjh07VmzP07V6KsyuXbskqVifqz/Ky8tTdna2W56fK8nvqTDucH46deqk3bt3a9euXfaf1q1bq1+/fvY/l5Rz5TKuvsv+dvXxxx9bPj4+1oIFC6x///vf1jPPPGNVqlTJSk5OdnVpN+Vvf/ublZCQYB0+fNj617/+ZUVFRVl+fn5Wamqqq0u7bhcuXLB27txp7dy505JkzZgxw9q5c6d19OhRy7Is65VXXrEqVapkffXVV9aPP/5ode/e3apTp47122+/ubjywl2tnwsXLlijRo2ykpKSrMOHD1tr1qyx7rrrLqt+/frWxYsXXV36FQ0ePNiqWLGilZCQYJ0+fdr+k5WVZV/n2WeftWrVqmWtW7fO2rZtmxUREWFFRES4sOqru1ZPBw4csKZMmWJt27bNOnz4sPXVV19ZdevWtTp06ODiygs3duxYa8OGDdbhw4etH3/80Ro7dqxls9msb7/91rIs9zs/lnX1ntzt/FzNnz8N6Y7nqjghYLnQrFmzrFq1alne3t5WWFiY9d1337m6pJvWu3dvq1q1apa3t7cVHBxs9e7d2zpw4ICry7oh69evtyQV+BkwYIBlWb8/qmHChAlWYGCg5ePjY3Xq1Mnat2+fa4u+iqv1k5WVZXXp0sXy9/e3vLy8rNq1a1uDBg0q9gG/sH4kWfPnz7ev89tvv1lDhgyxKleubJUpU8bq2bOndfr0adcVfQ3X6unYsWNWhw4drCpVqlg+Pj7WHXfcYf3973+3MjIyXFv4Ffz1r3+1ateubXl7e1v+/v5Wp06d7OHKstzv/FjW1Xtyt/NzNX8OWO54rooTm2VZVtHNlwEAAJR83IMFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABcBpFixYIJvNdsWf7777ztUlAoBTlHJ1AQBKvilTphT6JcZ33HGHC6oBAOcjYAFwuq5du6p169YurSEzM1Nly5Z1aQ0Abh9cIgTgUkeOHJHNZtNrr72md955R/Xq1ZOPj4/atGmj77//vsD6e/fu1SOPPKIqVarI19dXrVu31rJlyxzWyb80uWHDBg0ZMkQBAQGqUaOG/fXZs2erbt26Kl26tMLCwpSYmKiOHTuqY8eOkqRff/1VZcuW1YgRIwoc/8SJE/L09FR8fLzZNwJAicIMFgCny8jIUFpamsOYzWZT1apV7cuLFy/WhQsX9F//9V+y2WyaNm2aevXqpUOHDsnLy0uS9NNPP6ldu3YKDg7W2LFjVbZsWX3yySfq0aOHPvvsM/Xs2dPhGEOGDJG/v78mTpyozMxMSdLbb7+tYcOGKTIyUiNHjtSRI0fUo0cPVa5c2R7CypUrp549e2rJkiWaMWOGPD097fv86KOPZFmW+vXr55T3CkAJYQGAk8yfP9+SVOiPj4+PZVmWdfjwYUuSVbVqVSs9Pd2+7VdffWVJsr7++mv7WKdOnaxmzZpZFy9etI/l5eVZbdu2terXr1/guO3bt7cuXbpkH8/OzraqVq1qtWnTxsrNzbWPL1iwwJJk3XPPPfaxb775xpJkrVy50qGn5s2bO6wHAIXhEiEAp5s9e7ZWr17t8LNy5UqHdXr37q3KlSvblyMjIyVJhw4dkiSlp6dr3bp1euyxx3ThwgWlpaUpLS1NZ8+eVXR0tPbv36+TJ0867HPQoEEOs0/btm3T2bNnNWjQIJUq9X8T+P369XM4tiRFRUWpevXqWrRokX1sz549+vHHH/XEE0/c4jsCoKTjEiEApwsLC7vmTe61atVyWM4PPL/88osk6cCBA7IsSxMmTNCECRMK3UdqaqqCg4Pty3/+5OLRo0clFfz0YqlSpRQSEuIw5uHhoX79+untt99WVlaWypQpo0WLFsnX11ePPvroVXsBAAIWgGLhjzNNf2RZliQpLy9PkjRq1ChFR0cXuu6fg1Pp0qVvqab+/ftr+vTp+vLLL9WnTx8tXrxYf/nLX1SxYsVb2i+Ako+ABcAt1K1bV5Lk5eWlqKiom9pH7dq1Jf0+G3bvvffaxy9duqQjR46oefPmDus3bdpULVu21KJFi1SjRg0dO3ZMs2bNuskOANxOuAcLgFsICAhQx44dNXfuXJ0+fbrA62fOnLnmPlq3bq2qVavq3Xff1aVLl+zjixYtsl+K/LMnn3xS3377rWbOnKmqVauqa9euN98EgNsGM1gAnG7lypXau3dvgfG2bdvKw+P6/583e/ZstW/fXs2aNdOgQYNUt25dpaSkKCkpSSdOnNAPP/xw1e29vb01adIkPffcc7rvvvv02GOP6ciRI1qwYIHq1asnm81WYJu+fftq9OjR+uKLLzR48GD7IyMA4GoIWACcbuLEiYWOz58/3/5wz+vRuHFjbdu2TZMnT9aCBQt09uxZBQQEqGXLllc8xp8NGzZMlmXpH//4h0aNGqXQ0FAtW7ZMw4cPl6+vb4H1AwMD1aVLF61YsUJPPvnkddcK4PZms/LvIAWA21ReXp78/f3Vq1cvvfvuuwVe79mzp3bv3q0DBw64oDoA7oh7sADcVi5evKg//7/yf//3f5Wenl7obNrp06e1fPlyZq8A3BBmsADcVhISEjRy5Eg9+uijqlq1qnbs2KH3339fjRo10vbt2+Xt7S1JOnz4sP71r3/pvffe0/fff6+DBw8qKCjIxdUDcBfcgwXgthISEqKaNWvqjTfeUHp6uqpUqaL+/fvrlVdesYcrSdqwYYNiYmJUq1YtLVy4kHAF4IYwgwUAAGAY92ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADDs/wGh9otCMXJ2YwAAAABJRU5ErkJggg==",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sigmoid_reward_widget(lambda e, a: 1 / (1.0 + 0.1 * a * np.exp(10 - e)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9dac8de4-1a0f-4aea-97e8-123692c57d01",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "emevo-lab",
+   "language": "python",
+   "name": "emevo-lab"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/emevo/genetic_ops.py b/src/emevo/genetic_ops.py
index 2eabfa2a..37343d6e 100644
--- a/src/emevo/genetic_ops.py
+++ b/src/emevo/genetic_ops.py
@@ -105,19 +105,34 @@ def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
         return cast(jax.Array, jnp.where(is_mutated, noise_added, array))
 
 
+def _clip_minmax(
+    x: jax.Array,
+    clip_min: float | None = None,
+    clip_max: float | None = None,
+) -> jax.Array:
+    if clip_min is None and clip_max is None:
+        return x
+    return jnp.clip(x, a_min=clip_min, a_max=clip_max)
+
+
 @dataclasses.dataclass(frozen=True)
 class GaussianMutation(Mutation):
     std_dev: float
+    clip_min: float | None = None
+    clip_max: float | None = None
 
     def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
         std_normal = jax.random.normal(prng_key, shape=array.shape)
-        return array + std_normal * self.std_dev
+        res = array + std_normal * self.std_dev
+        return _clip_minmax(res, self.clip_min, self.clip_max)
 
 
 @dataclasses.dataclass(frozen=True)
 class UniformMutation(Mutation):
     min_noise: float
     max_noise: float
+    clip_min: float | None = None
+    clip_max: float | None = None
 
     def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
         uniform = jax.random.uniform(
@@ -126,4 +141,5 @@ def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
             minval=self.min_noise,
             maxval=self.max_noise,
         )
-        return array + uniform
+        res = array + uniform
+        return _clip_minmax(res, self.clip_min, self.clip_max)

From a3edbcea05ecccb97a98ed13f058a58411a81596 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 12 Jan 2024 17:33:23 +0900
Subject: [PATCH 185/337] Tweak on widget

---
 src/emevo/environments/qt_vis.py | 61 ++++++++++++++++----------------
 1 file changed, 30 insertions(+), 31 deletions(-)

diff --git a/src/emevo/environments/qt_vis.py b/src/emevo/environments/qt_vis.py
index 7dbbc557..f8a67c2b 100644
--- a/src/emevo/environments/qt_vis.py
+++ b/src/emevo/environments/qt_vis.py
@@ -22,7 +22,7 @@
 from PySide6.QtCore import Qt, QTimer, Signal, Slot
 from PySide6.QtGui import QGuiApplication, QMouseEvent, QPainter, QSurfaceFormat
 from PySide6.QtOpenGLWidgets import QOpenGLWidget
-from PySide6.QtWidgets import QGridLayout, QWidget
+from PySide6 import QtWidgets
 
 from emevo.environments.moderngl_vis import MglRenderer
 from emevo.environments.phyjax2d import Space, StateDict
@@ -45,7 +45,7 @@ class AppState:
     paused_before: bool = False
 
 
-class QtVisualizer(QOpenGLWidget):
+class MglWidget(QOpenGLWidget):
     selectionChanged = Signal(int)
 
     def __init__(
@@ -55,9 +55,9 @@ def __init__(
         y_range: float,
         space: Space,
         stated: StateDict,
-        figsize: tuple[float, float] | None = None,
+        figsize: tuple[float, float],
         sensor_fn: Callable[[StateDict], tuple[NDArray, NDArray]] | None = None,
-        parent: QWidget | None = None,
+        parent: QtWidgets.QWidget | None = None,
     ) -> None:
         # Set default format
         QSurfaceFormat.setDefaultFormat(_mgl_qsurface_fmt())
@@ -107,7 +107,7 @@ def paintGL(self) -> None:
     def render(self, stated: StateDict) -> None:
         self._fbo.use()
         self._ctx.clear(1.0, 1.0, 1.0)
-        self._renderer.render(self._env)  # type: ignore
+        self._renderer.render(stated)  # type: ignore
 
     def show(self, timer: QTimer):
         self._timer = timer
@@ -121,30 +121,25 @@ def _emit_selected(self, index: int | None) -> None:
 
     def mousePressEvent(self, evt: QMouseEvent) -> None:
         position = self._scale_position(evt.position())
-        query = self._env.get_space().point_query(
-            position,
-            0.0,
-            shape_filter=make_filter(CollisionType.AGENT, CollisionType.FOOD),
-        )
-        if len(query) == 1:
-            shape = query[0].shape
-            if shape is not None:
-                body_index = self._env.get_body_index(shape.body)
-                if body_index is not None:
-                    self._state.pantool.start_drag(position, shape, body_index)
-                    self._emit_selected(body_index)
-                    self._paused_before = self._state.paused
-                    self._state.paused = True
-                    self._timer.stop()
-                    self.update()
+        # query = self._env.get_space().point_query(
+        #     position,
+        #     0.0,
+        #     shape_filter=make_filter(CollisionType.AGENT, CollisionType.FOOD),
+        # )
+        # if len(query) == 1:
+        #     shape = query[0].shape
+        #     if shape is not None:
+        #         body_index = self._env.get_body_index(shape.body)
+        #         if body_index is not None:
+        #             self._state.pantool.start_drag(position, shape, body_index)
+        #             self._emit_selected(body_index)
+        #             self._paused_before = self._state.paused
+        #             self._state.paused = True
+        #             self._timer.stop()
+        #             self.update()
 
     def mouseReleaseEvent(self, evt: QMouseEvent) -> None:
-        if self._state.pantool.is_dragging:
-            self._state.pantool.stop_drag(self._scale_position(evt.position()))
-            self._emit_selected(None)
-            self._state.paused = self._state.paused_before
-            self._timer.start()
-            self.update()
+        pass
 
     @Slot()
     def pause(self) -> None:
@@ -155,7 +150,7 @@ def play(self) -> None:
         self._state.paused = False
 
 
-class BarChart(QWidget):
+class BarChart(QtWidgets.QWidget):
     def __init__(
         self,
         initial_values: dict[str, float | list[float]],
@@ -200,7 +195,7 @@ def __init__(
         self._chart_view.chart().show()
         self._chart_view.chart().legend().show()
         # create main layout
-        layout = QGridLayout(self)
+        layout = QtWidgets.QGridLayout(self)
         layout.addWidget(self._chart_view, 1, 1)
         self.setLayout(layout)
         self.setVisible(True)
@@ -209,9 +204,11 @@ def _make_barset(self, name: str, value: float | list[float]) -> QBarSet:
         barset = QBarSet(name)
         if isinstance(value, float):
             barset.append(value)
-        else:
+        elif isinstance(value, list):
             for v in value:
                 barset.append(v)
+        else:
+            raise ValueError(f"Invalid value for barset: {value}")
         self.barsets[name] = barset
         self.series.append(barset)
         return barset
@@ -233,9 +230,11 @@ def updateValues(self, values: dict[str, float | list[float]]) -> None:
                 new_barsets.append(barset)
             elif isinstance(value, float):
                 self.barsets[name].replace(0, value)
-            else:
+            elif isinstance(value, list):
                 for i, vi in enumerate(value):
                     self.barsets[name].replace(i, vi)
+            else:
+                raise ValueError(f"Invalid value for barset {value}")
 
         for name in list(self.barsets.keys()):
             if name not in values:

From 6642dedf7c56a2679c85028e165f214f9b1e9641 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 12 Jan 2024 18:52:15 +0900
Subject: [PATCH 186/337] Replay widget

---
 experiments/cf_asexual_evo.py                 |  40 ++++-
 pyproject.toml                                |   8 +-
 smoke-tests/circle_loop.py                    |   2 +-
 smoke-tests/circle_ppo.py                     |   5 +-
 .../qt_vis.py => analysis/qt_widget.py}       | 142 +++++++++++++++---
 src/emevo/environments/circle_foraging.py     |   2 +-
 src/emevo/environments/moderngl_vis.py        |  15 +-
 src/emevo/plotting.py                         |   7 +-
 src/emevo/visualizer.py                       |  16 +-
 9 files changed, 187 insertions(+), 50 deletions(-)
 rename src/emevo/{environments/qt_vis.py => analysis/qt_widget.py} (62%)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index e0bd6d1f..0c92c160 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -288,7 +288,7 @@ def replace_net(
         )
 
         if visualizer is not None:
-            visualizer.render(env_state)
+            visualizer.render(env_state.physics)  # type: ignore
             visualizer.show()
         # Extinct?
         n_active = jnp.sum(env_state.unique_id.is_active())  # type: ignore
@@ -429,8 +429,6 @@ def evolve(
                 "alpha_action": slice_last(alpha, 3),
             },
         )
-        print(reward_fn_instance.alpha)
-        print(reward_fn_instance.weight)
     else:
         raise ValueError(f"Invalid reward_fn {reward_fn}")
 
@@ -491,10 +489,44 @@ def replay(
     for i in range(start, end_index):
         phys = phys_state.set_by_index(i, env_state.physics)
         env_state = dataclasses.replace(env_state, physics=phys)
-        visualizer.render(env_state)
+        visualizer.render(env_state.physics)
         visualizer.show()
     visualizer.close()
 
 
+@app.command()
+def widget(
+    physstate_path: Path,
+    n_agents: int = 20,
+    start: int = 0,
+    end: Optional[int] = None,
+    cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
+    env_override: str = "",
+) -> None:
+    import sys
+
+    from PySide6.QtWidgets import QApplication
+
+    from emevo.analysis.qt_widget import CFEnvReplayWidget
+
+    with cfconfig_path.open("r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+    cfconfig.n_initial_agents = n_agents
+    cfconfig.apply_override(env_override)
+    phys_state = SavedPhysicsState.load(physstate_path)
+    env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
+    end_index = end if end is not None else phys_state.circle_axy.shape[0]
+
+    app = QApplication([])
+    widget = CFEnvReplayWidget(
+        int(cfconfig.xlim[1]),
+        int(cfconfig.ylim[1]),
+        env=env,  # type: ignore
+        saved_physics=phys_state,
+    )
+    widget.show()
+    sys.exit(app.exec())
+
+
 if __name__ == "__main__":
     app()
diff --git a/pyproject.toml b/pyproject.toml
index da993114..b2a973de 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -32,9 +32,13 @@ dependencies = [
 dynamic = ["version"]
 
 [project.optional-dependencies]
-analysis = ["networkx >= 3.0", "pygraphviz >= 1.0"]
+analysis = [
+    "matplotlib >= 3.0",
+    "networkx >= 3.0",
+    "pygraphviz >= 1.0",
+    "PySide6 >= 6.5",
+]
 video = ["imageio-ffmpeg >= 0.4"]
-widget = ["PySide6 >= 6.5"]
 
 [project.readme]
 file = "README.md"
diff --git a/smoke-tests/circle_loop.py b/smoke-tests/circle_loop.py
index ed12a784..e11d3dd3 100644
--- a/smoke-tests/circle_loop.py
+++ b/smoke-tests/circle_loop.py
@@ -100,7 +100,7 @@ def main(
                 print("Parents: ", parents)
 
         if visualizer is not None:
-            visualizer.render(state)
+            visualizer.render(state.physics)
             visualizer.show()
 
     print(f"Avg. μs for step: {np.mean(elapsed_list)}")
diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index 8d191845..3544441c 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -61,8 +61,9 @@ def step(key: chex.PRNGKey, state: State, obs: Obs) -> tuple[State, Obs, jax.Arr
 
     for key in keys[1:]:
         state, obs, act = step(key, state, obs)
+        del act
         # print(f"Act: {act[0]}")
-        visualizer.render(state)
+        visualizer.render(state.physics) # type: ignore
         visualizer.show()
 
 
@@ -201,7 +202,7 @@ def run_training(
         ri = jnp.sum(jnp.squeeze(rewards_i, axis=-1), axis=0)
         rewards = rewards + ri
         if visualizer is not None:
-            visualizer.render(env_state)
+            visualizer.render(env_state.physics)  # type: ignore
             visualizer.show()
             print(f"Rewards: {[x.item() for x in ri[: n_agents]]}")
         if reset:
diff --git a/src/emevo/environments/qt_vis.py b/src/emevo/analysis/qt_widget.py
similarity index 62%
rename from src/emevo/environments/qt_vis.py
rename to src/emevo/analysis/qt_widget.py
index f8a67c2b..68234b81 100644
--- a/src/emevo/environments/qt_vis.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -8,9 +8,15 @@
 from functools import partial
 from typing import Callable
 
+import jax
+import matplotlib as mpl
+import matplotlib.colors as mc
 import moderngl
 import numpy as np
+import pyarrow as pa
+from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg
 from numpy.typing import NDArray
+from PySide6 import QtWidgets
 from PySide6.QtCharts import (
     QBarCategoryAxis,
     QBarSeries,
@@ -19,13 +25,15 @@
     QChartView,
     QValueAxis,
 )
-from PySide6.QtCore import Qt, QTimer, Signal, Slot
+from PySide6.QtCore import QPointF, Qt, QTimer, Signal, Slot
 from PySide6.QtGui import QGuiApplication, QMouseEvent, QPainter, QSurfaceFormat
 from PySide6.QtOpenGLWidgets import QOpenGLWidget
-from PySide6 import QtWidgets
 
+from emevo.environments.circle_foraging import CircleForaging
 from emevo.environments.moderngl_vis import MglRenderer
-from emevo.environments.phyjax2d import Space, StateDict
+from emevo.environments.phyjax2d import StateDict
+from emevo.exp_utils import SavedPhysicsState
+from emevo.plotting import CBarRenderer
 
 
 def _mgl_qsurface_fmt() -> QSurfaceFormat:
@@ -51,38 +59,52 @@ class MglWidget(QOpenGLWidget):
     def __init__(
         self,
         *,
-        x_range: float,
-        y_range: float,
-        space: Space,
-        stated: StateDict,
+        timer: QTimer,
+        env: CircleForaging,
+        saved_physics: SavedPhysicsState,
         figsize: tuple[float, float],
-        sensor_fn: Callable[[StateDict], tuple[NDArray, NDArray]] | None = None,
         parent: QtWidgets.QWidget | None = None,
     ) -> None:
         # Set default format
         QSurfaceFormat.setDefaultFormat(_mgl_qsurface_fmt())
         super().__init__(parent)
         # init renderer
+        self._env_state, _ = env.reset(jax.random.PRNGKey(0))
         self._figsize = int(figsize[0]), int(figsize[1])
+        x_range, y_range = env._x_range, env._y_range
         self._scaling = x_range / figsize[0], y_range / figsize[1]
+        self._phys_state = saved_physics
         self._make_renderer = partial(
             MglRenderer,
             screen_width=self._figsize[0],
             screen_height=self._figsize[1],
             x_range=x_range,
             y_range=y_range,
-            space=space,
-            stated=stated,
-            sensor_fn=sensor_fn,
+            space=env._physics,
+            stated=self._get_stated(0),
+            sensor_fn=env._get_sensors,
         )
+        self._index = 0
         self._state = AppState()
         self._initialized = False
         self._overlay_fns = []
-        self._initial_state = stated
+
+        # Set timer
+        self._timer = timer
+        self._timer.timeout.connect(self.update)
 
         self.setFixedSize(*self._figsize)
         self.setMouseTracking(True)
 
+    def _scale_position(self, position: QPointF) -> tuple[float, float]:
+        return (
+            position.x() * self._scaling[0],
+            (self._figsize[1] - position.y()) * self._scaling[1],
+        )
+
+    def _get_stated(self, index: int) -> StateDict:
+        return self._phys_state.set_by_index(index, self._env_state.physics)
+
     def _set_default_viewport(self) -> None:
         self._ctx.viewport = 0, 0, *self._figsize
         self._fbo.viewport = 0, 0, *self._figsize
@@ -102,24 +124,21 @@ def paintGL(self) -> None:
             self._fbo = self._ctx.detect_framebuffer()
             self._renderer = self._make_renderer(self._ctx)
             self._initialized = True
-        self.render(self._initial_state)
+        self._index += 1
+        self._render(self._get_stated(self._index))
 
-    def render(self, stated: StateDict) -> None:
+    def _render(self, stated: StateDict) -> None:
         self._fbo.use()
         self._ctx.clear(1.0, 1.0, 1.0)
         self._renderer.render(stated)  # type: ignore
 
-    def show(self, timer: QTimer):
-        self._timer = timer
-        self._timer.timeout.connect(self.update)  # type: ignore
-
     def _emit_selected(self, index: int | None) -> None:
         if index is None:
             self.selectionChanged.emit(-1)
         else:
             self.selectionChanged.emit(index)
 
-    def mousePressEvent(self, evt: QMouseEvent) -> None:
+    def mousePressEvent(self, evt: QMouseEvent) -> None:  # type: ignore
         position = self._scale_position(evt.position())
         # query = self._env.get_space().point_query(
         #     position,
@@ -138,7 +157,7 @@ def mousePressEvent(self, evt: QMouseEvent) -> None:
         #             self._timer.stop()
         #             self.update()
 
-    def mouseReleaseEvent(self, evt: QMouseEvent) -> None:
+    def mouseReleaseEvent(self, evt: QMouseEvent) -> None:  # type: ignore
         pass
 
     @Slot()
@@ -242,3 +261,86 @@ def updateValues(self, values: dict[str, float | list[float]]) -> None:
                 new_barsets.popleft().setColor(old_bs.color())
                 self.series.remove(old_bs)
         self._update_yrange(values.values())
+
+
+class CFEnvReplayWidget(QtWidgets.QWidget):
+    energyUpdated = Signal(float)
+    rewardUpdated = Signal(dict)
+    foodrankUpdated = Signal(dict)
+    valueUpdated = Signal(float)
+
+    def __init__(
+        self,
+        xlim: int,
+        ylim: int,
+        env: CircleForaging,
+        saved_physics: SavedPhysicsState,
+        profile_and_reward: pa.Table | None = None,
+    ) -> None:
+        super().__init__()
+
+        timer = QTimer()
+        # Environment
+        self._mgl_widget = MglWidget(
+            timer=timer,
+            env=env,
+            saved_physics=saved_physics,
+            figsize=(xlim * 2, ylim * 2),
+        )
+        # Pause/Play
+        self._pause_button = QtWidgets.QPushButton("⏸️")
+        self._pause_button.clicked.connect(self._mgl_widget.pause)
+        self._play_button = QtWidgets.QPushButton("▶️")
+        self._play_button.clicked.connect(self._mgl_widget.play)
+        self._cbar_select_button = QtWidgets.QPushButton("Switch Value/Energy")
+        self._cbar_select_button.clicked.connect(self.change_cbar)
+        # Colorbar
+        self._cbar_renderer = CBarRenderer(xlim * 2, ylim // 4)
+        self._showing_energy = True
+        self._cbar_changed = True
+        self._cbar_canvas = FigureCanvasQTAgg(self._cbar_renderer._fig)
+        self._value_cm = mpl.colormaps["YlOrRd"]
+        self._energy_cm = mpl.colormaps["YlGnBu"]
+        self._norm = mc.Normalize(vmin=0.0, vmax=1.0)
+        if profile_and_reward is not None:
+            self._reward_widget = BarChart(
+                next(iter(self._rewards.values())).to_pydict()
+            )
+        # Layout buttons
+        buttons = QtWidgets.QHBoxLayout()
+        buttons.addWidget(self._pause_button)
+        buttons.addWidget(self._play_button)
+        buttons.addWidget(self._cbar_select_button)
+        # Total layout
+        total_layout = QtWidgets.QVBoxLayout()
+        total_layout.addLayout(buttons)
+        total_layout.addWidget(self._cbar_canvas)
+        if profile_and_reward is None:
+            total_layout.addWidget(self._mgl_widget)
+        else:
+            env_and_reward_layout = QtWidgets.QHBoxLayout()
+            env_and_reward_layout.addWidget(self._mgl_widget)
+            env_and_reward_layout.addWidget(self._reward_widget)
+            total_layout.addLayout(env_and_reward_layout)
+        self.setLayout(total_layout)
+        timer.start(30)  # 40fps
+        self._arrow_cached = None
+        self._obs_cached = {}
+        # Signals
+        self._mgl_widget.selectionChanged.connect(self.updateRewards)
+        if profile_and_reward is not None:
+            self.rewardUpdated.connect(self._reward_widget.updateValues)
+        # Initial size
+        self.resize(xlim * 3, int(ylim * 2.4))
+
+    @Slot(int)
+    def updateRewards(self, body_index: int) -> None:
+        pass
+        # if self._rewards is None or body_index == -1:
+        #     return
+        # self.rewardUpdated.emit(self._rewards[body_index].to_pydict())
+
+    @Slot()
+    def change_cbar(self) -> None:
+        self._showing_energy = not self._showing_energy
+        self._cbar_changed = True
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 19cfdee6..0e079bfa 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -865,7 +865,7 @@ def visualizer(
         figsize: tuple[float, float] | None = None,
         backend: str = "pyglet",
         **kwargs,
-    ) -> Visualizer:
+    ) -> Visualizer[StateDict]:
         """Create a visualizer for the environment"""
         from emevo.environments import moderngl_vis
 
diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index 28645fa6..9aa0d7ed 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -4,7 +4,7 @@
 """
 from __future__ import annotations
 
-from typing import Any, Callable, ClassVar, Protocol
+from typing import Any, Callable, ClassVar
 
 import jax.numpy as jnp
 import moderngl as mgl
@@ -16,10 +16,6 @@
 from emevo.environments.phyjax2d import Circle, Segment, Space, State, StateDict
 
 
-class HasStateD(Protocol):
-    stated: StateDict
-
-
 NOWHERE: float = -1000.0
 
 
@@ -598,16 +594,15 @@ def get_image(self) -> NDArray:
         w, h = self._figsize
         return output.reshape(h, w, -1)[::-1]
 
-    def overlay(self, name: str, value: Any) -> None:
+    def overlay(self, name: str, value: Any) -> Any:
         self._renderer.overlay(name, value)
 
-    def render(self, state: HasStateD) -> None:
+    def render(self, state: StateDict) -> None:
         self._window.clear(1.0, 1.0, 1.0)
         self._window.use()
-        self._renderer.render(stated=state.stated)
+        self._renderer.render(stated=state)
 
-    def show(self, *args, **kwargs) -> None:
-        del args, kwargs
+    def show(self) -> None:
         self._window.swap_buffers()
 
 
diff --git a/src/emevo/plotting.py b/src/emevo/plotting.py
index 5ae8e33b..94cbf4f8 100644
--- a/src/emevo/plotting.py
+++ b/src/emevo/plotting.py
@@ -34,7 +34,7 @@ def __init__(
             Figure,
             plt.figure(figsize=(width / dpi, height / dpi), dpi=dpi),
         )
-        self._ax: Axes = self._fig.add_axes([0.0, 0.2, 1.0, 0.6])
+        self._ax: Axes = self._fig.add_axes([0.0, 0.2, 1.0, 0.6])  # type: ignore
 
     def render(self, norm: Normalize, cm: Colormap, title: str = "Value") -> None:
         """Render cbar, but don't update figure"""
@@ -51,7 +51,10 @@ def render_to_array(
     ) -> NDArray:
         self.render(norm, cm, title)
         self._fig.canvas.draw()
-        array = np.frombuffer(self._fig.canvas.tostring_rgb(), dtype=np.uint8)
+        array = np.frombuffer(
+            self._fig.canvas.tostring_rgb(),  # type: ignore
+            dtype=np.uint8,
+        )
         w, h = self._fig.canvas.get_width_height()
         return array.reshape(h, w, -1)
 
diff --git a/src/emevo/visualizer.py b/src/emevo/visualizer.py
index 07fd52b7..4a28282b 100644
--- a/src/emevo/visualizer.py
+++ b/src/emevo/visualizer.py
@@ -16,16 +16,17 @@ def close(self) -> None:
     def get_image(self) -> NDArray:
         ...
 
-    def render(self, state: STATE) -> Any:
+    def render(self, state: STATE) -> None:
         """Render image"""
         ...
 
-    def show(self, *args, **kwargs) -> None:
+    def show(self) -> None:
         """Open a GUI window"""
         ...
 
-    def overlay(self, name: str, _value: Any) -> Any:
+    def overlay(self, name: str, value: Any) -> Any:
         """Render additional value as an overlay"""
+        del value
         raise ValueError(f"Unsupported overlay: {name}")
 
 
@@ -38,10 +39,10 @@ def close(self) -> None:
     def get_image(self) -> NDArray:
         return self.unwrapped.get_image()
 
-    def render(self, state: STATE) -> Any:
-        return self.unwrapped.render(state)
+    def render(self, state: STATE) -> None:
+        self.unwrapped.render(state)
 
-    def show(self, *args, **kwargs) -> None:
+    def show(self) -> None:
         self.unwrapped.show()
 
     def overlay(self, name: str, value: Any) -> Any:
@@ -66,8 +67,7 @@ def close(self) -> None:
         if self._writer is not None:
             self._writer.close()
 
-    def show(self, *args, **kwargs) -> None:
-        del args, kwargs
+    def show(self) -> None:
         self._count += 1
         image = self.unwrapped.get_image()
         if self._writer is None:

From 43618dd559c0dd3dcd9f47251a2ca20e06d4b66c Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 12 Jan 2024 23:51:04 +0900
Subject: [PATCH 187/337] Fix tests for reward fn

---
 src/emevo/reward_fn.py  |  8 ++++----
 tests/test_config.py    | 10 ++++++----
 tests/test_reward_fn.py | 26 +++++++++++++++-----------
 3 files changed, 25 insertions(+), 19 deletions(-)

diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 15fb4dab..d5589415 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -47,10 +47,10 @@ def __init__(
         key: chex.PRNGKey,
         n_agents: int,
         n_weights: int,
-        std: float,
-        mean: float,
         extractor: Callable[..., jax.Array],
         serializer: Callable[[jax.Array], dict[str, jax.Array]],
+        std: float = 1.0,
+        mean: float = 0.0,
     ) -> None:
         self.weight = jax.random.normal(key, (n_agents, n_weights)) * std + mean
         self.extractor = extractor
@@ -76,10 +76,10 @@ def __init__(
         key: chex.PRNGKey,
         n_agents: int,
         n_weights: int,
-        std: float,
-        mean: float,
         extractor: Callable[..., tuple[jax.Array, jax.Array]],
         serializer: Callable[[jax.Array, jax.Array], dict[str, jax.Array]],
+        std: float = 1.0,
+        mean: float = 0.0,
     ) -> None:
         k1, k2 = jax.random.split(key)
         self.weight = jax.random.normal(k1, (n_agents, n_weights)) * std + mean
diff --git a/tests/test_config.py b/tests/test_config.py
index b7df4c35..3484385f 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -22,12 +22,14 @@ def test_cfconfig() -> None:
 
 
 def test_gopsconfig() -> None:
-    with open("config/gops/20240111-mutation-0401.toml") as f:
+    with open("config/gops/20240112-mutation-0401-clipped.toml") as f:
         gopsconfig = toml.from_toml(GopsConfig, f.read())
 
     mutation = gopsconfig.load_model()
     assert isinstance(mutation, gops.BernoulliMixtureMutation)
-    assert mutation.mutation_prob == 0.2
+    assert mutation.mutation_prob == 0.4
     assert isinstance(mutation.mutator, gops.UniformMutation)
-    assert mutation.mutator.min_noise == -1
-    assert mutation.mutator.max_noise == 1
+    assert mutation.mutator.min_noise == -0.1
+    assert mutation.mutator.max_noise == 0.1
+    assert mutation.mutator.clip_min == -1
+    assert mutation.mutator.clip_max == 1
diff --git a/tests/test_reward_fn.py b/tests/test_reward_fn.py
index 4d022e5a..cca2f661 100644
--- a/tests/test_reward_fn.py
+++ b/tests/test_reward_fn.py
@@ -15,11 +15,15 @@ def slice_last(w: jax.Array, i: int) -> jax.Array:
 @pytest.fixture
 def reward_fn() -> LinearReward:
     return LinearReward(
-        jax.random.PRNGKey(43),
-        10,
-        3,
-        lambda x: x,  # Nothing to do
-        lambda w: {"a": slice_last(w, 0), "b": slice_last(w, 1), "c": slice_last(w, 2)},
+        key=jax.random.PRNGKey(43),
+        n_agents=10,
+        n_weights=3,
+        extractor=lambda x: x,  # Nothing to do
+        serializer=lambda w: {
+            "a": slice_last(w, 0),
+            "b": slice_last(w, 1),
+            "c": slice_last(w, 2),
+        },
     )
 
 
@@ -33,11 +37,11 @@ def test_sigmoid_reward_fn() -> None:
     inputs = jnp.zeros((10, 3))
     energy = jnp.zeros((10, 1))
     reward_fn = SigmoidReward(
-        jax.random.PRNGKey(43),
-        10,
-        3,
-        lambda x, y: (x, y),  # Nothing to do
-        lambda _, __: {},
+        key=jax.random.PRNGKey(43),
+        n_agents=10,
+        n_weights=3,
+        extractor=lambda x, y: (x, y),  # Nothing to do
+        serializer=lambda _, __: {},
     )
     reward = reward_fn(inputs, energy)
     chex.assert_shape(reward, (10,))
@@ -51,7 +55,7 @@ def test_serialise(reward_fn: LinearReward) -> None:
 def test_mutation(reward_fn: LinearReward) -> None:
     reward_fn_dict = {i + 1: get_slice(reward_fn, i) for i in range(5)}
     chex.assert_shape(tuple(map(lambda lr: lr.weight, reward_fn_dict.values())), (3,))
-    mutation = gops.GaussianMutation(std_dev=1.0)
+    mutation = gops.GaussianMutation(std_dev=1.0, clip_min=0.0)
     parents = jnp.array([-1, -1, -1, -1, -1, 2, 4, -1, -1, -1])
     mutated = mutate_reward_fn(
         jax.random.PRNGKey(23),

From edb3de3bc69f18235ddccb7a06a3efa7570a6ca4 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 13 Jan 2024 00:44:23 +0900
Subject: [PATCH 188/337] Fix phys state index

---
 setup-venv             | 8 ++------
 src/emevo/exp_utils.py | 2 +-
 2 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/setup-venv b/setup-venv
index 2044f898..99043ddb 100755
--- a/setup-venv
+++ b/setup-venv
@@ -6,10 +6,6 @@ if [[ ! -d .exp-venv ]]; then
     python3 -m venv .exp-venv
 fi
 
-if [[ ! -f requirements/experiments.txt ]]; then
-    nox -s compile -- -k experiments
-fi
-
 source .exp-venv/bin/activate
-pip install pip-tools
-pip-sync requirements/experiments.txt
+pip install -e .[analysis,video]
+pip install typer
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 3700c57e..e2f4a3f9 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -306,7 +306,7 @@ def _save_physstate(self) -> None:
             return
 
         concat_physstates(self._physstate_list).save(
-            self.logdir.joinpath(f"state-{self._physstate_index + 1}.npz")
+            self.logdir.joinpath(f"state-{self._physstate_index}.npz")
         )
         self._physstate_index += 1
         self._physstate_list.clear()

From 461fdebadf266aeb2ffc3cbfd287e1a3f5f18706 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 13 Jan 2024 02:18:24 +0900
Subject: [PATCH 189/337] 0404

---
 config/gops/20240113-mutation-0404-clipped.toml | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 config/gops/20240113-mutation-0404-clipped.toml

diff --git a/config/gops/20240113-mutation-0404-clipped.toml b/config/gops/20240113-mutation-0404-clipped.toml
new file mode 100644
index 00000000..a4602dd0
--- /dev/null
+++ b/config/gops/20240113-mutation-0404-clipped.toml
@@ -0,0 +1,15 @@
+path = "emevo.genetic_ops.BernoulliMixtureMutation"
+init_std = 0.1
+init_mean = 0.0
+
+[params]
+mutation_prob = 0.4
+
+[params.mutator]
+path = "emevo.genetic_ops.UniformMutation"
+
+[params.mutator.params]
+min_noise = -0.4
+max_noise = 0.4
+clip_min = -1.0
+clip_max = 1.0
\ No newline at end of file

From d993689addab2c6a20124da2bff2c6c5f8508980 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sun, 14 Jan 2024 00:04:41 +0900
Subject: [PATCH 190/337] Normalize action input to reward fn by max norm

---
 experiments/cf_asexual_evo.py | 97 +++++++++++++++++++++++------------
 notebooks/reward_fn.ipynb     | 83 ++++++++----------------------
 2 files changed, 84 insertions(+), 96 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 0c92c160..c9ee68a9 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -42,34 +42,53 @@
     vmap_update,
     vmap_value,
 )
+from emevo.spaces import BoxSpace
 from emevo.visualizer import SaveVideoWrapper
 
 
-def extract_reward_linear(
-    collision: jax.Array,
-    action: jax.Array,
-    _: jax.Array,
-) -> jax.Array:
-    action_norm = jnp.sqrt(jnp.sum(action**2, axis=-1, keepdims=True))
-    return jnp.concatenate((collision, action_norm), axis=1)
+class RewardKind(str, enum.Enum):
+    LINEAR = "linear"
+    SIGMOID = "sigmoid"
 
 
-def extract_reward_sigmoid(
-    collision: jax.Array,
-    action: jax.Array,
-    energy: jax.Array,
-) -> tuple[jax.Array, jax.Array]:
-    action_norm = jnp.sqrt(jnp.sum(action**2, axis=-1, keepdims=True))
-    return jnp.concatenate((collision, action_norm), axis=1), energy
+@dataclasses.dataclass
+class RewardExtractor:
+    act_space: BoxSpace
+    act_coef: float
+    max_norm: jax.Array = dataclasses.field(init=False)
 
+    def __post_init__(self) -> None:
+        self.max_norm = jnp.sqrt(
+            jnp.sum(self.act_space.high**2, axis=-1, keepdims=True)
+        )
 
-def slice_last(w: jax.Array, i: int) -> jax.Array:
-    return jnp.squeeze(jax.lax.slice_in_dim(w, i, i + 1, axis=-1))
+    def normalize_action(self, action: jax.Array) -> jax.Array:
+        scaled = self.act_space.sigmoid_scale(action)
+        norm = jnp.sqrt(jnp.sum(scaled**2, axis=-1, keepdims=True))
+        return norm / self.max_norm
+
+    def extract_linear(
+        self,
+        collision: jax.Array,
+        action: jax.Array,
+        energy: jax.Array,
+    ) -> jax.Array:
+        del energy
+        act_input = self.act_coef * self.normalize_action(action)
+        return jnp.concatenate((collision, act_input), axis=1)
+
+    def extract_sigmoid(
+        self,
+        collision: jax.Array,
+        action: jax.Array,
+        energy: jax.Array,
+    ) -> tuple[jax.Array, jax.Array]:
+        act_input = self.act_coef * self.normalize_action(action)
+        return jnp.concatenate((collision, act_input), axis=1), energy
 
 
-class RewardKind(str, enum.Enum):
-    LINEAR = "linear"
-    SIGMOID = "sigmoid"
+def slice_last(w: jax.Array, i: int) -> jax.Array:
+    return jnp.squeeze(jax.lax.slice_in_dim(w, i, i + 1, axis=-1))
 
 
 def exec_rollout(
@@ -190,7 +209,7 @@ def epoch(
         0.2,
         0.0,
     )
-    return env_state, obs, log, phys_state, opt_state, pponet
+    return env_state, obs, log, phys_state, opt_state, pponet, rollout.actions
 
 
 def run_evolution(
@@ -269,7 +288,7 @@ def replace_net(
 
     for i, key in enumerate(jax.random.split(key, n_total_steps // n_rollout_steps)):
         epoch_key, init_key = jax.random.split(key)
-        env_state, obs, log, phys_state, opt_state, pponet = epoch(
+        env_state, obs, log, phys_state, opt_state, pponet, act = epoch(
             env_state,
             obs,
             env,
@@ -287,6 +306,14 @@ def replace_net(
             n_optim_epochs,
         )
 
+        ###### Reward fn debug
+        for ac in act:
+            extracted = reward_fn.extractor(
+                jnp.ones((ac.shape[0], 3)), ac, log.energy[0]
+            )
+            print(jnp.max(extracted[:, 3]), jnp.min(extracted[:, 3]))
+        ###### End: Rewad fn debug
+
         if visualizer is not None:
             visualizer.render(env_state.physics)  # type: ignore
             visualizer.show()
@@ -358,6 +385,7 @@ def evolve(
     minibatch_size: int = 256,
     n_rollout_steps: int = 1024,
     n_total_steps: int = 1024 * 10000,
+    act_reward_coef: float = 0.01,
     cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
     bdconfig_path: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
     gopsconfig_path: Path = here.joinpath("../config/gops/20240111-mutation-0401.toml"),
@@ -395,14 +423,21 @@ def evolve(
     # Make env
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
     key, reward_key = jax.random.split(jax.random.PRNGKey(seed))
+    reward_extracor = RewardExtractor(
+        act_space=env.act_space,  # type: ignore
+        act_coef=act_reward_coef,
+    )
+    common_rewardfn_args = {
+        "key": reward_key,
+        "n_agents": cfconfig.n_max_agents,
+        "n_weights": 4,
+        "std": gopsconfig.init_std,
+        "mean": gopsconfig.init_mean,
+    }
     if reward_fn == RewardKind.LINEAR:
         reward_fn_instance = LinearReward(
-            key=reward_key,
-            n_agents=cfconfig.n_max_agents,
-            n_weights=4,
-            std=gopsconfig.init_std,
-            mean=gopsconfig.init_mean,
-            extractor=extract_reward_linear,
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_linear,
             serializer=lambda w: {
                 "agent": slice_last(w, 0),
                 "food": slice_last(w, 1),
@@ -412,12 +447,8 @@ def evolve(
         )
     elif reward_fn == RewardKind.SIGMOID:
         reward_fn_instance = SigmoidReward(
-            key=reward_key,
-            n_agents=cfconfig.n_max_agents,
-            n_weights=4,
-            std=gopsconfig.init_std,
-            mean=gopsconfig.init_mean,
-            extractor=extract_reward_sigmoid,
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
             serializer=lambda w, alpha: {
                 "w_agent": slice_last(w, 0),
                 "w_food": slice_last(w, 1),
diff --git a/notebooks/reward_fn.ipynb b/notebooks/reward_fn.ipynb
index 090f7243..42767426 100644
--- a/notebooks/reward_fn.ipynb
+++ b/notebooks/reward_fn.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 30,
    "id": "31f0ecac-d024-4106-8700-0f84004e753e",
    "metadata": {},
    "outputs": [],
@@ -32,7 +32,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 31,
    "id": "9de733db-cd24-4a67-ae28-f2e3ce2af415",
    "metadata": {},
    "outputs": [],
@@ -66,7 +66,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 32,
    "id": "df0fe701-8b83-4a0c-86f9-6d241cd930ea",
    "metadata": {},
    "outputs": [],
@@ -93,7 +93,7 @@
     "            ax.grid(True, which=\"major\")\n",
     "            ax.set_xlabel(\"Energy\", fontsize=12)\n",
     "            ax.set_ylabel(\"Reward Coef\", fontsize=12)\n",
-    "            ax.set_ylim((0.0, 1.0))\n",
+    "            # ax.set_ylim((-1.0, 1.0))\n",
     "        else:\n",
     "            state.line.remove()\n",
     "\n",
@@ -102,13 +102,13 @@
     "        fig.canvas.draw()\n",
     "        fig.canvas.flush_events()\n",
     "\n",
-    "    interactive = widgets.interactive(update_figure, alpha=make_slider(-2.0, 2.0, logscale=False, n_steps=n_discr))\n",
+    "    interactive = widgets.interactive(update_figure, alpha=make_slider(-1.0, 1.0, logscale=False, n_steps=n_discr))\n",
     "    return widgets.VBox([interactive])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 33,
    "id": "547967f9-2c4b-40bb-a244-fcad24150897",
    "metadata": {},
    "outputs": [
@@ -118,7 +118,7 @@
        "0.5"
       ]
      },
-     "execution_count": 38,
+     "execution_count": 33,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -129,40 +129,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 39,
    "id": "64594795-61ee-46f9-b8f0-35325a5e2f56",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "6ba92f872e6a4971afd6ffeb06c35ccc",
+       "model_id": "459f4ea3831e42b195f7e80685b67bfd",
        "version_major": 2,
        "version_minor": 0
       },
       "text/plain": [
-       "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=2.0, min=-2.0, step=0.004…"
+       "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=1.0, min=-1.0, step=0.002…"
       ]
      },
-     "execution_count": 40,
+     "execution_count": 39,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "7bbf3489745b4f6187be49a7ca6679db",
+       "model_id": "096d82fff06245deb58c6661bc19181e",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -175,64 +175,21 @@
     }
    ],
    "source": [
-    "sigmoid_reward_widget(lambda e, a: 1 / (1.0 + np.exp(- e * a * 0.5)))"
+    "sigmoid_reward_widget(lambda e, a: 2 / (1.0 + np.exp(- e * a)) - (1 if a > 0 else 0))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
-   "id": "e7383410-789d-422e-a1bd-fdd92ba629e6",
+   "execution_count": null,
+   "id": "0c07b29c-9c1d-4605-b966-b95f7ee3f521",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "7a8a122e41304167bf8cca461242b6d0",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=2.0, min=-2.0, step=0.004…"
-      ]
-     },
-     "execution_count": 29,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "2554b178c52d414c89dcf765d7014586",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "image/png": "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",
-      "text/html": [
-       "\n",
-       "            <div style=\"display: inline-block;\">\n",
-       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
-       "                    Figure\n",
-       "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
-       "            </div>\n",
-       "        "
-      ],
-      "text/plain": [
-       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "sigmoid_reward_widget(lambda e, a: 1 / (1.0 + 0.1 * a * np.exp(10 - e)))"
-   ]
+   "outputs": [],
+   "source": []
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "9dac8de4-1a0f-4aea-97e8-123692c57d01",
+   "id": "b91dd971-aa16-43ca-95e5-b20341f89df1",
    "metadata": {},
    "outputs": [],
    "source": []

From 052b9402ae6940152fc2d1a2d4abf55b609391d6 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sun, 14 Jan 2024 00:34:51 +0900
Subject: [PATCH 191/337] Sigmoid-01

---
 experiments/cf_asexual_evo.py | 36 ++++++++++++------
 notebooks/reward_fn.ipynb     | 71 ++++++++++++++++++++++++++++++-----
 src/emevo/reward_fn.py        | 10 +++++
 3 files changed, 96 insertions(+), 21 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index c9ee68a9..f08aa037 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -32,7 +32,13 @@
     SavedPhysicsState,
     SavedProfile,
 )
-from emevo.reward_fn import LinearReward, RewardFn, SigmoidReward, mutate_reward_fn
+from emevo.reward_fn import (
+    LinearReward,
+    RewardFn,
+    SigmoidReward,
+    SigmoidReward_01,
+    mutate_reward_fn,
+)
 from emevo.rl.ppo_normal import (
     NormalPPONet,
     Rollout,
@@ -49,6 +55,7 @@
 class RewardKind(str, enum.Enum):
     LINEAR = "linear"
     SIGMOID = "sigmoid"
+    SIGMOID_01 = "sigmoid-01"
 
 
 @dataclasses.dataclass
@@ -209,7 +216,7 @@ def epoch(
         0.2,
         0.0,
     )
-    return env_state, obs, log, phys_state, opt_state, pponet, rollout.actions
+    return env_state, obs, log, phys_state, opt_state, pponet
 
 
 def run_evolution(
@@ -288,7 +295,7 @@ def replace_net(
 
     for i, key in enumerate(jax.random.split(key, n_total_steps // n_rollout_steps)):
         epoch_key, init_key = jax.random.split(key)
-        env_state, obs, log, phys_state, opt_state, pponet, act = epoch(
+        env_state, obs, log, phys_state, opt_state, pponet = epoch(
             env_state,
             obs,
             env,
@@ -306,14 +313,6 @@ def replace_net(
             n_optim_epochs,
         )
 
-        ###### Reward fn debug
-        for ac in act:
-            extracted = reward_fn.extractor(
-                jnp.ones((ac.shape[0], 3)), ac, log.energy[0]
-            )
-            print(jnp.max(extracted[:, 3]), jnp.min(extracted[:, 3]))
-        ###### End: Rewad fn debug
-
         if visualizer is not None:
             visualizer.render(env_state.physics)  # type: ignore
             visualizer.show()
@@ -460,6 +459,21 @@ def evolve(
                 "alpha_action": slice_last(alpha, 3),
             },
         )
+    elif reward_fn == RewardKind.SIGMOID_01:
+        reward_fn_instance = SigmoidReward_01(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=lambda w, alpha: {
+                "w_agent": slice_last(w, 0),
+                "w_food": slice_last(w, 1),
+                "w_wall": slice_last(w, 2),
+                "w_action": slice_last(w, 3),
+                "alpha_agent": slice_last(alpha, 0),
+                "alpha_food": slice_last(alpha, 1),
+                "alpha_wall": slice_last(alpha, 2),
+                "alpha_action": slice_last(alpha, 3),
+            },
+        )
     else:
         raise ValueError(f"Invalid reward_fn {reward_fn}")
 
diff --git a/notebooks/reward_fn.ipynb b/notebooks/reward_fn.ipynb
index 42767426..198d7447 100644
--- a/notebooks/reward_fn.ipynb
+++ b/notebooks/reward_fn.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 2,
    "id": "31f0ecac-d024-4106-8700-0f84004e753e",
    "metadata": {},
    "outputs": [],
@@ -32,7 +32,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 3,
    "id": "9de733db-cd24-4a67-ae28-f2e3ce2af415",
    "metadata": {},
    "outputs": [],
@@ -66,7 +66,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 4,
    "id": "df0fe701-8b83-4a0c-86f9-6d241cd930ea",
    "metadata": {},
    "outputs": [],
@@ -108,7 +108,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 13,
    "id": "547967f9-2c4b-40bb-a244-fcad24150897",
    "metadata": {},
    "outputs": [
@@ -118,7 +118,7 @@
        "0.5"
       ]
      },
-     "execution_count": 33,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -129,14 +129,65 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 14,
+   "id": "a9fbd4a3-b9ef-437d-8db6-3771d6b1fef0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "772123856e224b60ad68d90b2bfc6957",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=1.0, min=-1.0, step=0.002…"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "01c1a95a4c4043ea8d60e4299a4995e8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAJYCAYAAAC+ZpjcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABFFElEQVR4nO3deVRV9f7/8dcBGUQFFRBUFETLKcURwsQsUbJJbbK0HG7ZN5WsuN7SfipqA01fM82b1i3plpXN2a1Mc+ZKWg5l3fSqOSsgDqCQgrB/f7g4346AMXzonIPPx1pnLfdn7/057/fZsny59z4bm2VZlgAAAGCMh7MLAAAAqG0IWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWEAtEBERoVGjRjm7jItKTU2VzWbT3r17/3Bbd+inpthsNk2fPr1S+5w+fVr33XefQkNDZbPZ9PDDD9dIbQAqjoAFuLBt27bptttuU3h4uHx9fdW8eXP1799fc+fOdXZpcCFPP/20UlNTNXbsWL311lu65557nF0ScMmzWZZlObsIAKWtX79e11xzjVq2bKmRI0cqNDRUBw4c0Lfffqvdu3dr165d9m3Pnj0rDw8PeXl5ObHiiysqKlJhYaF8fHxks9kuum1ERIT69u2r1NTUP6c4F2Kz2ZScnFyps1hXXnml6tSpo7S0tJorDECl1HF2AQDK9tRTTykgIEDfffedGjZs6LAuKyvLYdnHx+dPrKxqPD095enpWaPvce7cORUXF8vb27tG36c68vLyVK9ePaNzZmVlqUOHDkbnBFA9XCIEXNTu3bvVsWPHUuFKkpo0aeKwXNY9Sz/++KOuvvpq1a1bV2FhYXryySe1cOHCUvdBRURE6MYbb9Tq1avVo0cP1a1bV506ddLq1aslSR9//LE6deokX19fde/eXVu2bClVz8qVKxUXF6d69eqpYcOGGjRokH755ReHbcq6B8uyLD355JMKCwuTn5+frrnmGv38888V+nz27t0rm82mF154QbNnz1br1q3l4+Oj//znP5Kk7du367bbblPjxo3l6+urHj16aMmSJfb9T548KU9PT82ZM8c+lp2dLQ8PDwUGBur3J/fHjh2r0NBQ+/K6det0++23q2XLlvLx8VGLFi30yCOP6LfffnOocdSoUapfv752796t66+/Xg0aNNDw4cMlnT/r+Mgjjyg4OFgNGjTQzTffrIMHD1ao9xKrV6+WzWbTnj179MUXX8hms9k/45J177//vp566imFhYXJ19dX/fr1czj7CaBmcAYLcFHh4eFKT0/XTz/9pCuuuKJS+x46dEjXXHONbDabJk+erHr16ukf//hHuWe6du3apWHDhul//ud/dPfdd+uFF17QTTfdpPnz5+vxxx/XuHHjJEkpKSm64447tGPHDnl4nP//2TfffKOBAwcqMjJS06dP12+//aa5c+fqqquu0ubNmxUREVFundOmTdOTTz6p66+/Xtdff702b96sAQMGqKCgoMK9Lly4UGfOnNH9998vHx8fNW7cWD///LOuuuoqNW/eXJMmTVK9evX0/vvva/Dgwfroo480ZMgQNWzYUFdccYXWrl2rCRMmSJLS0tJks9l0/Phx/ec//1HHjh0lnQ9UcXFx9vf84IMPlJ+fr7FjxyowMFAbN27U3LlzdfDgQX3wwQcO9Z07d04JCQnq3bu3XnjhBfn5+UmS7rvvPr399tsaNmyYevXqpZUrV+qGG26ocN+S1L59e7311lt65JFHFBYWpr/+9a+SpODgYHuQfeaZZ+Th4aGJEycqJydHzz33nIYPH64NGzZU6r0AVJIFwCUtW7bM8vT0tDw9Pa3Y2Fjr0Ucftb7++muroKCg1Lbh4eHWyJEj7csPPvigZbPZrC1bttjHjh07ZjVu3NiSZO3Zs8dhX0nW+vXr7WNff/21JcmqW7eutW/fPvv4ggULLEnWqlWr7GNdunSxmjRpYh07dsw+9sMPP1geHh7WiBEj7GMLFy50eO+srCzL29vbuuGGG6zi4mL7do8//rglyaGfsuzZs8eSZPn7+1tZWVkO6/r162d16tTJOnPmjH2suLjY6tWrl3XZZZfZx8aPH2+FhITYl5OSkqw+ffpYTZo0sV555RX752az2ayXXnrJvl1+fn6pelJSUiybzebweY0cOdKSZE2aNMlh261bt1qSrHHjxjmMDxs2zJJkJScnX7T3C4WHh1s33HCDw9iqVassSVb79u2ts2fP2sdfeuklS5K1bdu2Sr0HgMrhEiHgovr376/09HTdfPPN+uGHH/Tcc88pISFBzZs3d7jUVZalS5cqNjZWXbp0sY81btzYfnnqQh06dFBsbKx9OSYmRpJ07bXXqmXLlqXGf/31V0nSkSNHtHXrVo0aNUqNGze2b9e5c2f1799fX375Zbk1fvPNNyooKNCDDz7ocNN7ZR8xcOuttyo4ONi+fPz4ca1cuVJ33HGHTp06pezsbGVnZ+vYsWNKSEjQzp07dejQIUlSXFycMjMztWPHDknnz1T16dNHcXFxWrdunaTzZ7Usy3I4g1W3bl37n/Py8pSdna1evXrJsqwyL6GOHTvWYbnkcyk5c1bV3iti9OjRDveklfRRcgwB1AwCFuDCevbsqY8//lgnTpzQxo0bNXnyZJ06dUq33Xab/V6jsuzbt09t2rQpNV7WmCSHECVJAQEBkqQWLVqUOX7ixAn7+0hS27ZtS83Zvn17ZWdnKy8vr9waJemyyy5zGA8ODlajRo3K3KcsrVq1cljetWuXLMvS1KlTFRwc7PBKTk6W9H9fEigJG+vWrVNeXp62bNmiuLg49enTxx6w1q1bJ39/f0VFRdnfY//+/fZQWb9+fQUHB+vqq6+WJOXk5DjUU6dOHYWFhZXq3cPDQ61bt3YYL+tzrK4Lj23JZ1tyDAHUDO7BAtyAt7e3evbsqZ49e+ryyy/X6NGj9cEHH9gDQ3WV9+2+8sYtF3q6y+/PJklScXGxJGnixIlKSEgoc5+SoNmsWTO1atVKa9euVUREhCzLUmxsrIKDg/XQQw9p3759WrdunXr16mW/56yoqEj9+/fX8ePH9dhjj6ldu3aqV6+eDh06pFGjRtnfv4SPj499X2dwh2MI1EYELMDN9OjRQ9L5y3PlCQ8PL/ObYqa/PRYeHi5J9ktsv7d9+3YFBQWV+0iCkn137typyMhI+/jRo0erdXalZC4vLy/Fx8f/4fZxcXFau3atWrVqpS5duqhBgwaKiopSQECAli5dqs2bN2vGjBn27bdt26b//ve/evPNNzVixAj7+PLlyytcY3h4uIqLi7V7926Hs1ZlfY4A3BOXCAEXtWrVqjLPMpTcv3Oxy0kJCQlKT0/X1q1b7WPHjx/XokWLjNbYtGlTdenSRW+++aZOnjxpH//pp5+0bNkyXX/99eXuGx8fLy8vL82dO9ehz9mzZ1erpiZNmqhv375asGBBmSH06NGjDstxcXHau3evFi9ebL9k6OHhoV69emnWrFkqLCx0uP+q5IzQ72u2LEsvvfRShWscOHCgJDk8IkKqfu8AXAdnsAAX9eCDDyo/P19DhgxRu3btVFBQoPXr12vx4sWKiIjQ6NGjy9330Ucf1dtvv63+/fvrwQcftD+moWXLljp+/PgfPkm9Mp5//nkNHDhQsbGxuvfee+2PaQgICLjo08iDg4M1ceJEpaSk6MYbb9T111+vLVu26KuvvlJQUFC1apo3b5569+6tTp06acyYMYqMjFRmZqbS09N18OBB/fDDD/ZtS8LTjh079PTTT9vH+/Tpo6+++ko+Pj7q2bOnfbxdu3Zq3bq1Jk6cqEOHDsnf318fffRRpc66denSRXfddZf+/ve/KycnR7169dKKFSt4PhVQixCwABf1wgsv6IMPPtCXX36pV199VQUFBWrZsqXGjRunKVOmlPkA0hItWrTQqlWrNGHCBD399NMKDg7W+PHjVa9ePU2YMEG+vr7G6oyPj9fSpUuVnJysadOmycvLS1dffbWeffbZUjegX+jJJ5+Ur6+v5s+fr1WrVikmJkbLli2r9POgLtShQwd9//33mjFjhlJTU3Xs2DE1adJEXbt21bRp0xy2bdu2rZo0aaKsrCz17t3bPl4SvKKjox2eH+bl5aXPP/9cEyZMUEpKinx9fTVkyBAlJiY63Aj/R9544w0FBwdr0aJF+vTTT3Xttdfqiy++KPXFAgDuid9FCFxCHn74YS1YsECnT5+u8V9bAwCXMu7BAmqpC39ty7Fjx/TWW2+pd+/ehCsAqGFcIgRqqdjYWPXt21ft27dXZmamXn/9deXm5mrq1KnOLg0VUFRUVOqG/AvVr19f9evX/5MqAlAZBCyglrr++uv14Ycf6tVXX5XNZlO3bt30+uuvq0+fPs4uDRVw4MCBP7yHLTk5+aJfJADgPNyDBQAu6MyZM0pLS7voNpGRkQ7PEAPgOghYAAAAhnGTOwAAgGHcg1VBxcXFOnz4sBo0aGD0IY0AANR2lmXp1KlTatasmVN/N+efiYBVQYcPH+YBgAAAVMOBAwcUFhbm7DL+FASsCmrQoIGk8385/P39jcxZWFioZcuWacCAAfLy8jIyp7PRk3ugJ9dX2/qR6Mld1ERPubm5atGihf3f0ksBAauCSi4L+vv7Gw1Yfn5+8vf3r1U/mPTk+ujJ9dW2fiR6chc12dOldIvNpXEhFAAA4E9EwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMc9mANW/ePEVERMjX11cxMTHauHFjudumpqbKZrM5vHx9fe3rCwsL9dhjj6lTp06qV6+emjVrphEjRujw4cN/RisAAOAS45IBa/HixUpKSlJycrI2b96sqKgoJSQkKCsrq9x9/P39deTIEftr37599nX5+fnavHmzpk6dqs2bN+vjjz/Wjh07dPPNN/8Z7QAAgEtMHWcXUJZZs2ZpzJgxGj16tCRp/vz5+uKLL/TGG29o0qRJZe5js9kUGhpa5rqAgAAtX77cYezll19WdHS09u/fr5YtW5ptAAAAXNJcLmAVFBRo06ZNmjx5sn3Mw8ND8fHxSk9PL3e/06dPKzw8XMXFxerWrZuefvppdezYsdztc3JyZLPZ1LBhwzLXnz17VmfPnrUv5+bmSjp/ubGwsLCSXZWtZB5T87kCenIP9OT6als/Ej25i5roqTZ9PhVlsyzLcnYRv3f48GE1b95c69evV2xsrH380Ucf1Zo1a7Rhw4ZS+6Snp2vnzp3q3LmzcnJy9MILL2jt2rX6+eefFRYWVmr7M2fO6KqrrlK7du20aNGiMuuYPn26ZsyYUWr8nXfekZ+fXzU6BADg0pKfn69hw4YpJydH/v7+zi7nT1ErAtaFCgsL1b59e91111164oknSq279dZbdfDgQa1evbrcA13WGawWLVooOzvb2F+OwsJCLV++XP3795eXl5eROZ2NntwDPbm+2taPRE/uoiZ6ys3NVVBQ0CUVsFzuEmFQUJA8PT2VmZnpMJ6ZmVnuPVYX8vLyUteuXbVr1y6H8cLCQt1xxx3at2+fVq5cedGD7OPjIx8fnzLnNv1DVBNzOhs9uQd6cn21rR+JntyFyZ5q22dTES73LUJvb291795dK1assI8VFxdrxYoVDme0LqaoqEjbtm1T06ZN7WMl4Wrnzp365ptvFBgYaLx2AAAAyQXPYElSUlKSRo4cqR49eig6OlqzZ89WXl6e/VuFI0aMUPPmzZWSkiJJmjlzpq688kq1adNGJ0+e1PPPP699+/bpvvvuk3Q+XN12223avHmz/vWvf6moqEgZGRmSpMaNG8vb29s5jQIAgFrJJQPW0KFDdfToUU2bNk0ZGRnq0qWLli5dqpCQEEnS/v375eHxfyffTpw4oTFjxigjI0ONGjVS9+7dtX79enXo0EGSdOjQIS1ZskSS1KVLF4f3WrVqlfr27fun9AUAAC4NLhmwJCkxMVGJiYllrlu9erXD8osvvqgXX3yx3LkiIiLkYvfyAwCAWszl7sECAABwdwQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYS4ZsObNm6eIiAj5+voqJiZGGzduLHfb1NRU2Ww2h5evr6/DNh9//LEGDBigwMBA2Ww2bd26tYY7AAAAlzKXC1iLFy9WUlKSkpOTtXnzZkVFRSkhIUFZWVnl7uPv768jR47YX/v27XNYn5eXp969e+vZZ5+t6fIBAABUx9kFXGjWrFkaM2aMRo8eLUmaP3++vvjiC73xxhuaNGlSmfvYbDaFhoaWO+c999wjSdq7d6/xegEAAC7kUgGroKBAmzZt0uTJk+1jHh4eio+PV3p6ern7nT59WuHh4SouLla3bt309NNPq2PHjtWq5ezZszp79qx9OTc3V5JUWFiowsLCas1domQeU/O5AnpyD/Tk+mpbPxI9uYua6Kk2fT4VZbMsy3J2ESUOHz6s5s2ba/369YqNjbWPP/roo1qzZo02bNhQap/09HTt3LlTnTt3Vk5Ojl544QWtXbtWP//8s8LCwhy23bt3r1q1aqUtW7aoS5cuF61l+vTpmjFjRqnxd955R35+flVrEACAS1B+fr6GDRumnJwc+fv7O7ucP4VLncGqitjYWIcw1qtXL7Vv314LFizQE088UeV5J0+erKSkJPtybm6uWrRooQEDBhj7y1FYWKjly5erf//+8vLyMjKns9GTe6An11fb+pHoyV3URE8lV4EuJS4VsIKCguTp6anMzEyH8czMzIveY/V7Xl5e6tq1q3bt2lWtWnx8fOTj41Pm/KZ/iGpiTmejJ/dAT66vtvUj0ZO7MNlTbftsKsKlvkXo7e2t7t27a8WKFfax4uJirVixwuEs1cUUFRVp27Ztatq0aU2VCQAAcFEudQZLkpKSkjRy5Ej16NFD0dHRmj17tvLy8uzfKhwxYoSaN2+ulJQUSdLMmTN15ZVXqk2bNjp58qSef/557du3T/fdd599zuPHj2v//v06fPiwJGnHjh2SpNDQ0AqfGQMAAKgolwtYQ4cO1dGjRzVt2jRlZGSoS5cuWrp0qUJCQiRJ+/fvl4fH/514O3HihMaMGaOMjAw1atRI3bt31/r169WhQwf7NkuWLLEHNEm68847JUnJycmaPn36n9MYAAC4ZLhcwJKkxMREJSYmlrlu9erVDssvvviiXnzxxYvON2rUKI0aNcpQdQAAABfnUvdgAQAA1AYELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEVDlhLlizR4cOHa7IWAACAWqHCAWvIkCFavXq1fTkyMlJLliypiZoAAADcWoUDVoMGDXTy5En78t69e3X69OmaqAkAAMCt1anohtHR0XrqqaeUmZmpgIAASdKXX36pjIyMcvex2Wx65JFHql8lAACAG6lwwPr73/+uESNG6IknnpB0Pjy98847euedd8rdh4AFAAAuRRUOWG3atNH69et15swZZWVlKSIiQrNnz9agQYNqsj4AAAC3U+GAVcLX11ctW7ZUcnKyrr32WoWHh9dEXQAAAG6r0gGrRHJysv3PR44cUVZWltq0aaN69eoZKQwAAMBdVetBo5999pnatWunsLAwdevWTRs2bJAkZWdnq2vXrvr0009N1AgAAOBWqhywPv/8c91yyy0KCgpScnKyLMuyrwsKClLz5s21cOFCI0UCAAC4kyoHrJkzZ6pPnz5KS0vT+PHjS62PjY3Vli1bqlUcAACAO6pywPrpp590xx13lLs+JCREWVlZVZ0eAADAbVU5YPn5+SkvL6/c9b/++qsCAwOrOj0AAIDbqnLAuuaaa/Tmm2/q3LlzpdZlZGTotdde04ABA6pVHAAAgDuqcsB66qmndPDgQfXs2VMLFiyQzWbT119/rSlTpqhTp06yLMvhUQ4AAACXiioHrLZt2yotLU2BgYGaOnWqLMvS888/r6efflqdOnXSunXrFBERYbBUAAAA91DlB41KUseOHfXNN9/oxIkT2rVrl4qLixUZGang4GBT9QEAALidagWsEo0aNVLPnj1NTAUAAOD2qvUk99zcXM2YMUPR0dEKCQlRSEiIoqOjNXPmTOXm5pqqEQAAwK1UOWAdPnxYXbt21YwZM3T69GldddVVuuqqq5SXl6fp06erW7duOnLkiMlaAQAA3EKVLxE+9thjysjI0L/+9S9df/31Duu++uor3X777Zo0aZLefPPNahcJAADgTqp8Bmvp0qV6+OGHS4UrSRo4cKAmTJigL7/8slrFAQAAuKMqB6y8vDyFhISUuz40NPSiT3oHAACoraocsDp06KB3331XBQUFpdYVFhbq3XffVYcOHapVHAAAgDuq1j1YQ4cOVXR0tMaNG6fLL79ckrRjxw7Nnz9fP/74oxYvXmysUAAAAHdR5YB1++23Ky8vT5MmTdIDDzwgm80mSbIsS02aNNEbb7yh2267zVihAAAA7qJaDxodNWqU7r77bn3//ffat2+fJCk8PFw9evRQnTpGnmEKAADgdqqdgurUqaMrr7xSV155pYl6AAAA3F6lbnI/cuSI2rVrp6lTp150uylTpqh9+/bKysqqVnEAAADuqFIB66WXXtLx48f12GOPXXS7xx57TMePH9fcuXOrVRwAAIA7qlTA+uKLL3TXXXepfv36F92uQYMGGjZsmJYsWVKt4gAAANxRpQLW7t271blz5wpt27FjR+3atatKRQEAALizSgUsT0/PMh8sWpbCwkJ5eFT5OaYAAABuq1IJqHXr1kpLS6vQtv/+97/VunXrKhUFAADgzioVsIYMGaIPPvhA6enpF93u22+/1fvvv68hQ4ZUqzgAAAB3VKmAlZSUpLCwMA0YMEDPPvusDh065LD+0KFDevbZZzVgwACFhYXpkUceMVosAACAO6hUwGrQoIG++eYbtW7dWpMnT1bLli3VuHFjhYeHq3HjxmrZsqUmT56sVq1aafny5fL396+pugEAAFxWpZ/kHhkZqU2bNunDDz/UkiVLtH37duXm5qpVq1Zq166dbrrpJt122238qhwAAHDJqlIK8vT01NChQzV06FDT9QAAALg9nqMAAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADKvwYxpmzpxZ6cltNpumTp1a6f0AAADcWYUD1vTp00uN2Ww2SZJlWaXGLcsiYAEAgEtShS8RFhcXO7wOHDigTp066a677tLGjRuVk5OjnJwcbdiwQXfeeaeioqJ04MCBmqwdAADAJVX5Hqzx48frsssu09tvv60ePXqoQYMGatCggXr27KlFixapdevWGj9+fJULmzdvniIiIuTr66uYmBht3Lix3G1TU1Nls9kcXr6+vg7bWJaladOmqWnTpqpbt67i4+O1c+fOKtcHAABQnioHrJUrV+raa68td32/fv20YsWKKs29ePFiJSUlKTk5WZs3b1ZUVJQSEhKUlZVV7j7+/v46cuSI/bVv3z6H9c8995zmzJmj+fPna8OGDapXr54SEhJ05syZKtUIAABQnir/RmZfX1+lp6dr7NixZa5fv359qbNIFTVr1iyNGTNGo0ePliTNnz9fX3zxhd544w1NmjSpzH1sNptCQ0PLXGdZlmbPnq0pU6Zo0KBBkqR//vOfCgkJ0aeffqo777yzSnVWh2VZKvjNUlGBhwp+s1R8rvhPr6EmnCukJ3dAT66vtvUj0ZO7KOnpwvurUTlVDljDhw/XnDlz1LBhQz344INq3bq1JGn37t2aM2eO3nnnHU2YMKHS8xYUFGjTpk2aPHmyfczDw0Px8fFKT08vd7/Tp08rPDxcxcXF6tatm55++ml17NhRkrRnzx5lZGQoPj7evn1AQIBiYmKUnp5eZsA6e/aszp49a1/Ozc2VJBUWFqqwsLDSfZXq8zdLU64/Lqmn1r10vNrzuRZ6cg/05PpqWz8SPbmLnrr22kLZ/G1GZjPx76a7qXLAevbZZ5Wdna2XX35Z8+bNk4fH+auNxcXFsixLd911l5599tlKz5udna2ioiKFhIQ4jIeEhGj79u1l7tO2bVu98cYb6ty5s3JycvTCCy+oV69e+vnnnxUWFqaMjAz7HBfOWbLuQikpKZoxY0ap8WXLlsnPz6/SfV2oqMBDUs9qzwMAQE1YuXKlPL3NnJXLz883Mo87qXLA8vb21ltvvaW//e1v+vLLL+33PIWHh2vgwIGKiooyVuQfiY2NVWxsrH25V69eat++vRYsWKAnnniiSnNOnjxZSUlJ9uXc3Fy1aNFCAwYMkL+/f7VrtixL115baL+XzcvLq9pzuoLCQnpyB/Tk+mpbPxI9uYuSnhKuv1be3t5G5iy5CnQpqVLAys/P1913361bb71Vw4cPV+fOnY0VFBQUJE9PT2VmZjqMZ2ZmlnuP1YW8vLzUtWtX7dq1S5Ls+2VmZqpp06YOc3bp0qXMOXx8fOTj41Pm3KZ+iGz+Nnl6F6uev3ct+sGkJ3dAT66vtvUj0ZO7KOnJ29tcT7Xls6mMKn2L0M/PT998802NnPLz9vZW9+7dHb6BWFxcrBUrVjicpbqYoqIibdu2zR6mWrVqpdDQUIc5c3NztWHDhgrPCQAAUFFVfkxD7969L3rTeXUkJSXptdde05tvvqlffvlFY8eOVV5env1bhSNGjHC4CX7mzJlatmyZfv31V23evFl333239u3bp/vuu0/S+W8YPvzww3ryySe1ZMkSbdu2TSNGjFCzZs00ePDgGukBAABcuqp8D9bLL7+shIQETZkyRQ888IDCwsKMFTV06FAdPXpU06ZNU0ZGhrp06aKlS5fab1Lfv3+//aZ6STpx4oTGjBmjjIwMNWrUSN27d9f69evVoUMH+zaPPvqo8vLydP/99+vkyZPq3bu3li5dWuVHSQAAAJSnygErKipK586dU0pKilJSUlSnTp1S9yzZbDbl5ORUaf7ExEQlJiaWuW716tUOyy+++KJefPHFi85ns9k0c+bMKv3SagAAgMqocsC69dZb7b/sGQAAAP+nygErNTXVYBkAAAC1R5VvcgcAAEDZqnwGq8TBgwe1ZcsW5eTkqLi49BNfR4wYUd23AAAAcCtVDlhnzpzRyJEj9dFHH6m4uFg2m83+iyF/f28WAQsAAFxqqnyJ8PHHH9fHH3+sp556SqtXr5ZlWXrzzTe1bNky+6/K+eGHH0zWCgAA4BaqHLA+/PBDjR49Wo899pg6duwoSWrevLni4+P1r3/9Sw0bNtS8efOMFQoAAOAuqhywsrKyFB0dLUmqW7euJCkvL8++/tZbb9XHH39czfIAAADcT5UDVkhIiI4dOybp/O8mbNSokXbs2GFfn5ubqzNnzlS/QgAAADdT5ZvcY2JilJaWpscee0ySdNNNN+n5559X06ZNVVxcrBdffFFXXnmlsUIBAADcRZXPYE2YMEGRkZE6e/asJOmJJ55Qw4YNdc8992jkyJEKCAjQnDlzjBUKAADgLqp8Bqt3797q3bu3fblFixb65ZdftG3bNnl6eqpdu3aqU6faj9kCAABwO0YTkIeHh6KiokxOCQAA4HaqHLCaNWumuLg4+4tgBQAAcF6VA9agQYOUlpamDz/8UJLk7++vXr16qU+fPoqLi1PPnj3l5eVlrFAAAAB3UeWA9corr0iSTpw4oXXr1mndunVKS0vTtGnTdO7cOfn4+CgmJkarVq0yViwAAIA7qPY9WI0aNdLNN9+sm2++WQcOHNBXX32lWbNm6b///a/Wrl1rokYAAAC3Uq2A9csvv9jPXq1bt04HDhxQQECAYmNjNXr0aMXFxZmqEwAAwG1UOWAFBwfr+PHjatKkieLi4vTXv/7VfrO7zWYzWSMAAIBbqfKDRo8dOyabzaZ27dqpffv2at++vS677DLCFQAAuORV+QzW0aNHlZaWpnXr1mnp0qVKSUmRJHXp0sX+6IbevXsrKCjIWLEAAADuoMoBKzAwUIMGDdKgQYMkSfn5+UpPT9e6dev0/vvva/bs2bLZbDp37pyxYgEAANyBkSe579y5U+vWrdPatWu1bt067dmzR9L5+7QAAAAuNVUOWC+//LLWrl2rtLQ0ZWZmyrIstWrVSnFxcXr88ccVFxenyy+/3GStAAAAbqHKAevhhx/WFVdcoVtvvdV+z1XTpk1N1gYAAOCWqhywjh07poCAAJO1AAAA1ApVfkzD78PVkSNH9MMPPygvL89IUQAAAO6sygFLkj777DO1a9dOYWFh6tatmzZs2CBJys7OVteuXfXpp5+aqBEAAMCtVDlgff7557rlllsUFBSk5ORkWZZlXxcUFKTmzZtr4cKFRooEAABwJ1UOWDNnzlSfPn2Ulpam8ePHl1ofGxurLVu2VKs4AAAAd1TlgPXTTz/pjjvuKHd9SEiIsrKyqjo9AACA26pywPLz87voTe2//vqrAgMDqzo9AACA26pywLrmmmv05ptvlvmrcDIyMvTaa69pwIAB1SoOAADAHVU5YD311FM6ePCgevbsqQULFshms+nrr7/WlClT1KlTJ1mWpeTkZJO1AgAAuIUqB6y2bdsqLS1NgYGBmjp1qizL0vPPP6+nn35anTp10rp16xQREWGwVAAAAPdQrV/23LFjR33zzTc6ceKEdu3apeLiYkVGRtp/ybNlWbLZbEYKBQAAcBfVetBoiUaNGqlnz56KiYlRcHCwCgoK9Oqrr6pt27YmpgcAAHArlT6DVVBQoCVLlmj37t1q1KiRbrzxRjVr1kySlJ+fr5dfflmzZ89WRkaGWrdubbxgAAAAV1epgHX48GH17dtXu3fvtj+5vW7dulqyZIm8vb01bNgwHTp0SNHR0Zo7d65uueWWGikaAADAlVUqYP2///f/tGfPHj366KOKi4vTnj17NHPmTN1///3Kzs5Wx44d9fbbb+vqq6+uqXoBAABcXqUC1vLlyzV69GilpKTYx0JDQ3X77bfrhhtu0GeffSYPDyO3dQEAALitSqWhzMxMXXnllQ5jJct/+ctfCFcAAACqZMAqKiqSr6+vw1jJckBAgLmqAAAA3Filv0W4d+9ebd682b6ck5MjSdq5c6caNmxYavtu3bpVvToAAAA3VOmANXXqVE2dOrXU+Lhx4xyWSx4yWlRUVPXqAAAA3FClAtbChQtrqg4AAIBao1IBa+TIkTVVBwAAQK3B1/4AAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMc8mANW/ePEVERMjX11cxMTHauHFjhfZ77733ZLPZNHjwYIfxzMxMjRo1Ss2aNZOfn5+uu+467dy5swYqBwAAcMGAtXjxYiUlJSk5OVmbN29WVFSUEhISlJWVddH99u7dq4kTJyouLs5h3LIsDR48WL/++qs+++wzbdmyReHh4YqPj1deXl5NtgIAAC5RLhewZs2apTFjxmj06NHq0KGD5s+fLz8/P73xxhvl7lNUVKThw4drxowZioyMdFi3c+dOffvtt3rllVfUs2dPtW3bVq+88op+++03vfvuuzXdDgAAuAS5VMAqKCjQpk2bFB8fbx/z8PBQfHy80tPTy91v5syZatKkie69995S686ePStJ8vX1dZjTx8dHaWlpBqsHAAA4r46zC/i97OxsFRUVKSQkxGE8JCRE27dvL3OftLQ0vf7669q6dWuZ69u1a6eWLVtq8uTJWrBggerVq6cXX3xRBw8e1JEjR8qt5ezZs/ZwJkm5ubmSpMLCQhUWFlays7KVzGNqPldAT+6BnlxfbetHoid3URM91abPp6JcKmBV1qlTp3TPPffotddeU1BQUJnbeHl56eOPP9a9996rxo0by9PTU/Hx8Ro4cKAsyyp37pSUFM2YMaPU+LJly+Tn52esB0lavny50flcAT25B3pyfbWtH4me3IXJnvLz843N5S5cKmAFBQXJ09NTmZmZDuOZmZkKDQ0ttf3u3bu1d+9e3XTTTfax4uJiSVKdOnW0Y8cOtW7dWt27d9fWrVuVk5OjgoICBQcHKyYmRj169Ci3lsmTJyspKcm+nJubqxYtWmjAgAHy9/evbquSzif65cuXq3///vLy8jIyp7PRk3ugJ9dX2/qR6Mld1ERPJVeBLiUuFbC8vb3VvXt3rVixwv6oheLiYq1YsUKJiYmltm/Xrp22bdvmMDZlyhSdOnVKL730klq0aOGwLiAgQNL5G9+///57PfHEE+XW4uPjIx8fn1LjXl5exn+IamJOZ6Mn90BPrq+29SPRk7sw2VNt+2wqwqUCliQlJSVp5MiR6tGjh6KjozV79mzl5eVp9OjRkqQRI0aoefPmSklJka+vr6644gqH/Rs2bChJDuMffPCBgoOD1bJlS23btk0PPfSQBg8erAEDBvxpfQEAgEuHywWsoUOH6ujRo5o2bZoyMjLUpUsXLV261H7j+/79++XhUbkvPx45ckRJSUnKzMxU06ZNNWLECE2dOrUmygcAAHC9gCVJiYmJZV4SlKTVq1dfdN/U1NRSYxMmTNCECRMMVAYAAPDHXOo5WAAAALUBAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGCYSwasefPmKSIiQr6+voqJidHGjRsrtN97770nm82mwYMHO4yfPn1aiYmJCgsLU926ddWhQwfNnz+/BioHAABwwYC1ePFiJSUlKTk5WZs3b1ZUVJQSEhKUlZV10f327t2riRMnKi4urtS6pKQkLV26VG+//bZ++eUXPfzww0pMTNSSJUtqqg0AAHAJc7mANWvWLI0ZM0ajR4+2n2ny8/PTG2+8Ue4+RUVFGj58uGbMmKHIyMhS69evX6+RI0eqb9++ioiI0P3336+oqKgKnxkDAACoDJcKWAUFBdq0aZPi4+PtYx4eHoqPj1d6enq5+82cOVNNmjTRvffeW+b6Xr16acmSJTp06JAsy9KqVav03//+VwMGDDDeAwAAQB1nF/B72dnZKioqUkhIiMN4SEiItm/fXuY+aWlpev3117V169Zy5507d67uv/9+hYWFqU6dOvLw8NBrr72mPn36lLvP2bNndfbsWftybm6uJKmwsFCFhYWV6Kp8JfOYms8V0JN7oCfXV9v6kejJXdRET7Xp86kolwpYlXXq1Cndc889eu211xQUFFTudnPnztW3336rJUuWKDw8XGvXrtX48ePVrFkzh7Nlv5eSkqIZM2aUGl+2bJn8/PyM9SBJy5cvNzqfK6An90BPrq+29SPRk7sw2VN+fr6xudyFzbIsy9lFlCgoKJCfn58+/PBDh28Cjhw5UidPntRnn33msP3WrVvVtWtXeXp62seKi4slnb+0uGPHDjVr1kwBAQH65JNPdMMNN9i3u++++3Tw4EEtXbq0zFrKOoPVokULZWdny9/f30S7Kiws1PLly9W/f395eXkZmdPZ6Mk90JPrq239SPTkLmqip9zcXAUFBSknJ8fYv6GuzqXOYHl7e6t79+5asWKFPWAVFxdrxYoVSkxMLLV9u3bttG3bNoexKVOm6NSpU3rppZfUokULnTlzRoWFhfLwcLzdzNPT0x7GyuLj4yMfH59S415eXsZ/iGpiTmejJ/dAT66vtvUj0ZO7MNlTbftsKsKlApZ0/pEKI0eOVI8ePRQdHa3Zs2crLy9Po0ePliSNGDFCzZs3V0pKinx9fXXFFVc47N+wYUNJso97e3vr6quv1t/+9jfVrVtX4eHhWrNmjf75z39q1qxZf2pvAADg0uByAWvo0KE6evSopk2bpoyMDHXp0kVLly613/i+f//+Umej/sh7772nyZMna/jw4Tp+/LjCw8P11FNP6YEHHqiJFgAAwCXO5QKWJCUmJpZ5SVCSVq9efdF9U1NTS42FhoZq4cKFBioDAAD4Yy71HCwAAIDagIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGFbH2QW4C8uyJEm5ubnG5iwsLFR+fr5yc3Pl5eVlbF5noif3QE+ur7b1I9GTu6iJnkr+7Sz5t/RSQMCqoFOnTkmSWrRo4eRKAABwT6dOnVJAQICzy/hT2KxLKU5WQ3FxsQ4fPqwGDRrIZrMZmTM3N1ctWrTQgQMH5O/vb2ROZ6Mn90BPrq+29SPRk7uoiZ4sy9KpU6fUrFkzeXhcGncncQargjw8PBQWFlYjc/v7+9eaH8wS9OQe6Mn11bZ+JHpyF6Z7ulTOXJW4NGIkAADAn4iABQAAYBgBy4l8fHyUnJwsHx8fZ5diDD25B3pyfbWtH4me3EVt7MkZuMkdAADAMM5gAQAAGEbAAgAAMIyABQAAYBgBCwAAwDAClhPNmzdPERER8vX1VUxMjDZu3Ojskqps+vTpstlsDq927do5u6xKWbt2rW666SY1a9ZMNptNn376qcN6y7I0bdo0NW3aVHXr1lV8fLx27tzpnGIr4I/6GTVqVKljdt111zmn2ApKSUlRz5491aBBAzVp0kSDBw/Wjh07HLY5c+aMxo8fr8DAQNWvX1+33nqrMjMznVTxH6tIT3379i11rB544AEnVXxxr7zyijp37mx/SGVsbKy++uor+3p3Oz7SH/fkTsenPM8884xsNpsefvhh+5g7HitXQsByksWLFyspKUnJycnavHmzoqKilJCQoKysLGeXVmUdO3bUkSNH7K+0tDRnl1QpeXl5ioqK0rx588pc/9xzz2nOnDmaP3++NmzYoHr16ikhIUFnzpz5kyutmD/qR5Kuu+46h2P27rvv/okVVt6aNWs0fvx4ffvtt1q+fLkKCws1YMAA5eXl2bd55JFH9Pnnn+uDDz7QmjVrdPjwYd1yyy1OrPriKtKTJI0ZM8bhWD333HNOqvjiwsLC9Mwzz2jTpk36/vvvde2112rQoEH6+eefJbnf8ZH+uCfJfY5PWb777jstWLBAnTt3dhh3x2PlUiw4RXR0tDV+/Hj7clFRkdWsWTMrJSXFiVVVXXJyshUVFeXsMoyRZH3yySf25eLiYis0NNR6/vnn7WMnT560fHx8rHfffdcJFVbOhf1YlmWNHDnSGjRokFPqMSUrK8uSZK1Zs8ayrPPHxMvLy/rggw/s2/zyyy+WJCs9Pd1ZZVbKhT1ZlmVdffXV1kMPPeS8oqqpUaNG1j/+8Y9acXxKlPRkWe59fE6dOmVddtll1vLlyx36qE3Hylk4g+UEBQUF2rRpk+Lj4+1jHh4eio+PV3p6uhMrq56dO3eqWbNmioyM1PDhw7V//35nl2TMnj17lJGR4XDMAgICFBMT49bHbPXq1WrSpInatm2rsWPH6tixY84uqVJycnIkSY0bN5Ykbdq0SYWFhQ7HqV27dmrZsqXbHKcLeyqxaNEiBQUF6YorrtDkyZOVn5/vjPIqpaioSO+9957y8vIUGxtbK47PhT2VcMfjI0njx4/XDTfc4HBMpNrxs+Rs/LJnJ8jOzlZRUZFCQkIcxkNCQrR9+3YnVVU9MTExSk1NVdu2bXXkyBHNmDFDcXFx+umnn9SgQQNnl1dtGRkZklTmMStZ526uu+463XLLLWrVqpV2796txx9/XAMHDlR6ero8PT2dXd4fKi4u1sMPP6yrrrpKV1xxhaTzx8nb21sNGzZ02NZdjlNZPUnSsGHDFB4ermbNmunHH3/UY489ph07dujjjz92YrXl27Ztm2JjY3XmzBnVr19fn3zyiTp06KCtW7e67fEpryfJ/Y5Piffee0+bN2/Wd999V2qdu/8suQICFowYOHCg/c+dO3dWTEyMwsPD9f777+vee+91YmUoz5133mn/c6dOndS5c2e1bt1aq1evVr9+/ZxYWcWMHz9eP/30k9vd63cx5fV0//332//cqVMnNW3aVP369dPu3bvVunXrP7vMP9S2bVtt3bpVOTk5+vDDDzVy5EitWbPG2WVVS3k9dejQwe2OjyQdOHBADz30kJYvXy5fX19nl1MrcYnQCYKCguTp6Vnq2xiZmZkKDQ11UlVmNWzYUJdffrl27drl7FKMKDkutfmYRUZGKigoyC2OWWJiov71r39p1apVCgsLs4+HhoaqoKBAJ0+edNjeHY5TeT2VJSYmRpJc9lh5e3urTZs26t69u1JSUhQVFaWXXnrJrY9PeT2VxdWPj3T+EmBWVpa6deumOnXqqE6dOlqzZo3mzJmjOnXqKCQkxG2PlasgYDmBt7e3unfvrhUrVtjHiouLtWLFCodr+u7s9OnT2r17t5o2bersUoxo1aqVQkNDHY5Zbm6uNmzYUGuO2cGDB3Xs2DGXPmaWZSkxMVGffPKJVq5cqVatWjms7969u7y8vByO044dO7R//36XPU5/1FNZtm7dKkkufax+r7i4WGfPnnXL41Oekp7K4g7Hp1+/ftq2bZu2bt1qf/Xo0UPDhw+3/7m2HCuncfZd9peq9957z/Lx8bFSU1Ot//znP9b9999vNWzY0MrIyHB2aVXy17/+1Vq9erW1Z88e69///rcVHx9vBQUFWVlZWc4urcJOnTplbdmyxdqyZYslyZo1a5a1ZcsWa9++fZZlWdYzzzxjNWzY0Prss8+sH3/80Ro0aJDVqlUr67fffnNy5WW7WD+nTp2yJk6caKWnp1t79uyxvvnmG6tbt27WZZddZp05c8bZpZdr7NixVkBAgLV69WrryJEj9ld+fr59mwceeMBq2bKltXLlSuv777+3YmNjrdjYWCdWfXF/1NOuXbusmTNnWt9//721Z88e67PPPrMiIyOtPn36OLnysk2aNMlas2aNtWfPHuvHH3+0Jk2aZNlsNmvZsmWWZbnf8bGsi/fkbsfnYi78NqQ7HitXQsByorlz51otW7a0vL29rejoaOvbb791dklVNnToUKtp06aWt7e31bx5c2vo0KHWrl27nF1WpaxatcqSVOo1cuRIy7LOP6ph6tSpVkhIiOXj42P169fP2rFjh3OLvoiL9ZOfn28NGDDACg4Otry8vKzw8HBrzJgxLh/wy+pHkrVw4UL7Nr/99ps1btw4q1GjRpafn581ZMgQ68iRI84r+g/8UU/79++3+vTpYzVu3Njy8fGx2rRpY/3tb3+zcnJynFt4Of7yl79Y4eHhlre3txUcHGz169fPHq4sy/2Oj2VdvCd3Oz4Xc2HAcsdj5UpslmVZf975MgAAgNqPe7AAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwANSY1NRU2Wy2cl/ffvuts0sEgBpRx9kFAKj9Zs6cWeYvMW7Tpo0TqgGAmkfAAlDjBg4cqB49eji1hry8PNWrV8+pNQC4dHCJEIBT7d27VzabTS+88IJeffVVtW7dWj4+PurZs6e+++67Uttv375dt912mxo3bixfX1/16NFDS5Yscdim5NLkmjVrNG7cODVp0kRhYWH29fPmzVNkZKTq1q2r6OhorVu3Tn379lXfvn0lSadPn1a9evX00EMPlXr/gwcPytPTUykpKWY/CAC1CmewANS4nJwcZWdnO4zZbDYFBgbal9955x2dOnVK//M//yObzabnnntOt9xyi3799Vd5eXlJkn7++WddddVVat68uSZNmqR69erp/fff1+DBg/XRRx9pyJAhDu8xbtw4BQcHa9q0acrLy5MkvfLKK0pMTFRcXJweeeQR7d27V4MHD1ajRo3sIax+/foaMmSIFi9erFmzZsnT09M+57vvvivLsjR8+PAa+awA1BIWANSQhQsXWpLKfPn4+FiWZVl79uyxJFmBgYHW8ePH7ft+9tlnliTr888/t4/169fP6tSpk3XmzBn7WHFxsdWrVy/rsssuK/W+vXv3ts6dO2cfP3v2rBUYGGj17NnTKiwstI+npqZakqyrr77aPvb1119bkqyvvvrKoafOnTs7bAcAZeESIYAaN2/ePC1fvtzh9dVXXzlsM3ToUDVq1Mi+HBcXJ0n69ddfJUnHjx/XypUrdccdd+jUqVPKzs5Wdna2jh07poSEBO3cuVOHDh1ymHPMmDEOZ5++//57HTt2TGPGjFGdOv93An/48OEO7y1J8fHxatasmRYtWmQf++mnn/Tjjz/q7rvvruYnAqC24xIhgBoXHR39hze5t2zZ0mG5JPCcOHFCkrRr1y5ZlqWpU6dq6tSpZc6RlZWl5s2b25cv/Obivn37JJX+9mKdOnUUERHhMObh4aHhw4frlVdeUX5+vvz8/LRo0SL5+vrq9ttvv2gvAEDAAuASfn+m6fcsy5IkFRcXS5ImTpyohISEMre9MDjVrVu3WjWNGDFCzz//vD799FPdddddeuedd3TjjTcqICCgWvMCqP0IWADcQmRkpCTJy8tL8fHxVZojPDxc0vmzYddcc419/Ny5c9q7d686d+7ssP0VV1yhrl27atGiRQoLC9P+/fs1d+7cKnYA4FLCPVgA3EKTJk3Ut29fLViwQEeOHCm1/ujRo384R48ePRQYGKjXXntN586ds48vWrTIfinyQvfcc4+WLVum2bNnKzAwUAMHDqx6EwAuGZzBAlDjvvrqK23fvr3UeK9eveThUfH/582bN0+9e/dWp06dNGbMGEVGRiozM1Pp6ek6ePCgfvjhh4vu7+3trenTp+vBBx/UtddeqzvuuEN79+5VamqqWrduLZvNVmqfYcOG6dFHH9Unn3yisWPH2h8ZAQAXQ8ACUOOmTZtW5vjChQvtD/esiA4dOuj777/XjBkzlJqaqmPHjqlJkybq2rVrue9xocTERFmWpf/93//VxIkTFRUVpSVLlmjChAny9fUttX1ISIgGDBigL7/8Uvfcc0+FawVwabNZJXeQAsAlqri4WMHBwbrlllv02muvlVo/ZMgQbdu2Tbt27XJCdQDcEfdgAbiknDlzRhf+v/Kf//ynjh8/XubZtCNHjuiLL77g7BWASuEMFoBLyurVq/XII4/o9ttvV2BgoDZv3qzXX39d7du316ZNm+Tt7S1J2rNnj/7973/rH//4h7777jvt3r1boaGhTq4egLvgHiwAl5SIiAi1aNFCc+bM0fHjx9W4cWONGDFCzzzzjD1cSdKaNWs0evRotWzZUm+++SbhCkClcAYLAADAMO7BAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABg2P8HufxaSR0KkwkAAAAASUVORK5CYII=",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sigmoid_reward_widget(lambda e, a: 1.0 / (1.0 + np.exp(- e * a)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
    "id": "64594795-61ee-46f9-b8f0-35325a5e2f56",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "459f4ea3831e42b195f7e80685b67bfd",
+       "model_id": "3b6b52ecbe854f6e80c55ce82ab00d4c",
        "version_major": 2,
        "version_minor": 0
       },
@@ -144,14 +195,14 @@
        "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=1.0, min=-1.0, step=0.002…"
       ]
      },
-     "execution_count": 39,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "096d82fff06245deb58c6661bc19181e",
+       "model_id": "524432b6b5be483ea79cfd578837f8dd",
        "version_major": 2,
        "version_minor": 0
       },
@@ -175,7 +226,7 @@
     }
    ],
    "source": [
-    "sigmoid_reward_widget(lambda e, a: 2 / (1.0 + np.exp(- e * a)) - (1 if a > 0 else 0))"
+    "sigmoid_reward_widget(lambda e, a: 2.0 / (1.0 + np.exp(- e * a)) - (a > 0))"
    ]
   },
   {
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index d5589415..4fbbbbd7 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -97,6 +97,16 @@ def serialise(self) -> dict[str, float | NDArray]:
         return jax.tree_map(_item_or_np, self.serializer(self.weight, self.alpha))
 
 
+class SigmoidReward_01(SigmoidReward):
+    """Scaled to [0, 1] for all alpha in [-1, 1]"""
+
+    def __call__(self, *args) -> jax.Array:
+        extracted, energy = self.extractor(*args)
+        energy_alpha = energy.reshape(-1, 1) * self.alpha  # (N, n_weights)
+        filtered = 2.0 * extracted / (1.0 + jnp.exp(-energy_alpha)) - self.alpha > 0
+        return jax.vmap(jnp.dot)(filtered, self.weight)
+
+
 def mutate_reward_fn(
     key: chex.PRNGKey,
     reward_fn_dict: dict[int, RF],

From 2be92853e58aaf94ad8ad11dcbf899704f56344f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sun, 14 Jan 2024 01:01:33 +0900
Subject: [PATCH 192/337] Bug fix in Sigmoid01

---
 src/emevo/reward_fn.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 4fbbbbd7..ef025e61 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -103,7 +103,7 @@ class SigmoidReward_01(SigmoidReward):
     def __call__(self, *args) -> jax.Array:
         extracted, energy = self.extractor(*args)
         energy_alpha = energy.reshape(-1, 1) * self.alpha  # (N, n_weights)
-        filtered = 2.0 * extracted / (1.0 + jnp.exp(-energy_alpha)) - self.alpha > 0
+        filtered = 2.0 * extracted / (1.0 + jnp.exp(-energy_alpha)) - (self.alpha > 0)
         return jax.vmap(jnp.dot)(filtered, self.weight)
 
 

From abaa8fc24083d5a62c46ec1649851458af97eb34 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sun, 14 Jan 2024 01:01:43 +0900
Subject: [PATCH 193/337] Use def instead of lambda for serializers

---
 experiments/cf_asexual_evo.py | 51 +++++++++++++++++------------------
 1 file changed, 25 insertions(+), 26 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index f08aa037..329ec1ea 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -98,6 +98,28 @@ def slice_last(w: jax.Array, i: int) -> jax.Array:
     return jnp.squeeze(jax.lax.slice_in_dim(w, i, i + 1, axis=-1))
 
 
+def linear_reward_serializer(w: jax.Array) -> dict[str, jax.Array]:
+    return {
+        "agent": slice_last(w, 0),
+        "food": slice_last(w, 1),
+        "wall": slice_last(w, 2),
+        "action": slice_last(w, 3),
+    }
+
+
+def sigmoid_reward_serializer(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
+    return {
+        "w_agent": slice_last(w, 0),
+        "w_food": slice_last(w, 1),
+        "w_wall": slice_last(w, 2),
+        "w_action": slice_last(w, 3),
+        "alpha_agent": slice_last(alpha, 0),
+        "alpha_food": slice_last(alpha, 1),
+        "alpha_wall": slice_last(alpha, 2),
+        "alpha_action": slice_last(alpha, 3),
+    }
+
+
 def exec_rollout(
     state: State,
     initial_obs: Obs,
@@ -437,42 +459,19 @@ def evolve(
         reward_fn_instance = LinearReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_linear,
-            serializer=lambda w: {
-                "agent": slice_last(w, 0),
-                "food": slice_last(w, 1),
-                "wall": slice_last(w, 2),
-                "action": slice_last(w, 3),
-            },
+            serializer=linear_reward_serializer,
         )
     elif reward_fn == RewardKind.SIGMOID:
         reward_fn_instance = SigmoidReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_sigmoid,
-            serializer=lambda w, alpha: {
-                "w_agent": slice_last(w, 0),
-                "w_food": slice_last(w, 1),
-                "w_wall": slice_last(w, 2),
-                "w_action": slice_last(w, 3),
-                "alpha_agent": slice_last(alpha, 0),
-                "alpha_food": slice_last(alpha, 1),
-                "alpha_wall": slice_last(alpha, 2),
-                "alpha_action": slice_last(alpha, 3),
-            },
+            serializer=sigmoid_reward_serializer,
         )
     elif reward_fn == RewardKind.SIGMOID_01:
         reward_fn_instance = SigmoidReward_01(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_sigmoid,
-            serializer=lambda w, alpha: {
-                "w_agent": slice_last(w, 0),
-                "w_food": slice_last(w, 1),
-                "w_wall": slice_last(w, 2),
-                "w_action": slice_last(w, 3),
-                "alpha_agent": slice_last(alpha, 0),
-                "alpha_food": slice_last(alpha, 1),
-                "alpha_wall": slice_last(alpha, 2),
-                "alpha_action": slice_last(alpha, 3),
-            },
+            serializer=sigmoid_reward_serializer,
         )
     else:
         raise ValueError(f"Invalid reward_fn {reward_fn}")

From 8f2ee352bac49da859504ee0d98a75cb81adb808 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 15 Jan 2024 00:49:39 +0900
Subject: [PATCH 194/337] Remove overlay

---
 src/emevo/environments/moderngl_vis.py | 75 --------------------------
 src/emevo/visualizer.py                |  8 ---
 2 files changed, 83 deletions(-)

diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index 9aa0d7ed..8d78f864 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -284,33 +284,6 @@ def _collect_heads(circle: Circle, state: State) -> NDArray:
     return np.where(flag, np.concatenate((p1, p2), axis=1).reshape(-1, 2), NOWHERE)
 
 
-# def _collect_policies(
-#     circle: Circle,
-#     state: State,
-#     max_arrow_length: float,
-# ) -> NDArray:
-# max_f = max(map(lambda bp: bp[1].max(), bodies_and_policies))
-# policy_scaling = max_arrow_length / max_f
-# points = []
-# radius = None
-# for body, policy in bodies_and_policies:
-#     a = body.position
-#     if radius is None:
-#         radius = next(
-#             filter(lambda shape: isinstance(shape, pymunk.Circle), body.shapes)
-#         ).radius
-#     f1, f2 = policy
-#     from1 = a + pymunk.Vec2d(0, radius).rotated(body.angle + np.pi * 0.75)
-#     to1 = from1 + pymunk.Vec2d(0, -f1 * policy_scaling).rotated(body.angle)
-#     from2 = a + pymunk.Vec2d(0, radius).rotated(body.angle - np.pi * 0.75)
-#     to2 = from2 + pymunk.Vec2d(0, -f2 * policy_scaling).rotated(body.angle)
-#     points.append(from1)
-#     points.append(to1)
-#     points.append(from2)
-#     points.append(to2)
-# return np.array(points, dtype=np.float32)
-
-
 def _get_clip_ranges(lengthes: list[float]) -> list[tuple[float, float]]:
     """Clip ranges to [-1, 1]"""
     total = sum(lengthes)
@@ -440,7 +413,6 @@ def collect_sensors(stated: StateDict) -> NDArray:
             program=head_program,
             segments=_collect_heads(space.shaped.circle, stated.circle),
         )
-        self._overlays = {}
 
     def _make_gl_program(
         self,
@@ -469,50 +441,6 @@ def _make_gl_program(
             prog[key].write(value)  # type: ignore
         return prog
 
-    def overlay(self, name: str, value: Any) -> Any:
-        """Render additional value as an overlay"""
-        key = name.lower()
-        if key == "arrow":
-            # Not implmented yet
-            # segments = _collect_policies(value, self._range_min * 0.1)
-            segments = np.zeros(1)
-            if "arrow" in self._overlays:
-                do_render = self._overlays["arrow"].update(segments)
-            else:
-                arrow_program = self._make_gl_program(
-                    vertex_shader=_LINE_VERTEX_SHADER,
-                    geometry_shader=_ARROW_GEOMETRY_SHADER,
-                    fragment_shader=_LINE_FRAGMENT_SHADER,
-                    color=np.array([0.98, 0.45, 0.45, 1.0], dtype=np.float32),
-                )
-                self._overlays["arrow"] = SegmentVA(
-                    ctx=self._context,
-                    program=arrow_program,
-                    segments=segments,
-                )
-                do_render = True
-            if do_render:
-                self._overlays["arrow"].render()
-        elif key.startswith("stack"):
-            xi, yi = map(int, key.split("-")[1:])
-            image = np.flipud(value)
-            h, w = image.shape[:2]
-            image_bytes = image.tobytes()
-            if key not in self._overlays:
-                texture = self._context.texture((w, h), 3, image_bytes)
-                texture.build_mipmaps()
-                program = self._make_gl_program(
-                    vertex_shader=_TEXTURE_VERTEX_SHADER,
-                    fragment_shader=_TEXTURE_FRAGMENT_SHADER,
-                    screen_idx=(xi, yi),
-                    game_x=(0.0, 1.0),
-                    game_y=(0.0, 1.0),
-                )
-                self._overlays[key] = TextureVA(self._context, program, texture)
-            self._overlays[key].update(image_bytes)
-            self._overlays[key].render()
-        else:
-            raise ValueError(f"Unsupported overlay in moderngl visualizer: {name}")
 
     def render(self, stated: StateDict) -> None:
         circles = _collect_circles(
@@ -594,9 +522,6 @@ def get_image(self) -> NDArray:
         w, h = self._figsize
         return output.reshape(h, w, -1)[::-1]
 
-    def overlay(self, name: str, value: Any) -> Any:
-        self._renderer.overlay(name, value)
-
     def render(self, state: StateDict) -> None:
         self._window.clear(1.0, 1.0, 1.0)
         self._window.use()
diff --git a/src/emevo/visualizer.py b/src/emevo/visualizer.py
index 4a28282b..4508d906 100644
--- a/src/emevo/visualizer.py
+++ b/src/emevo/visualizer.py
@@ -24,11 +24,6 @@ def show(self) -> None:
         """Open a GUI window"""
         ...
 
-    def overlay(self, name: str, value: Any) -> Any:
-        """Render additional value as an overlay"""
-        del value
-        raise ValueError(f"Unsupported overlay: {name}")
-
 
 class VisWrapper(Visualizer[STATE], Protocol):
     unwrapped: Visualizer[STATE]
@@ -45,9 +40,6 @@ def render(self, state: STATE) -> None:
     def show(self) -> None:
         self.unwrapped.show()
 
-    def overlay(self, name: str, value: Any) -> Any:
-        return self.unwrapped.overlay(name, value)
-
 
 class SaveVideoWrapper(VisWrapper[STATE]):
     def __init__(

From 7af7f7e57d610f5717999ce52728c9bbe80e4e78 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 15 Jan 2024 00:50:15 +0900
Subject: [PATCH 195/337] Load log for widget

---
 experiments/cf_asexual_evo.py   | 41 ++++++++++++++++++++----------
 src/emevo/analysis/qt_widget.py | 45 ++++++++++++++++++++++-----------
 2 files changed, 58 insertions(+), 28 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 329ec1ea..744aa440 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -545,13 +545,11 @@ def widget(
     start: int = 0,
     end: Optional[int] = None,
     cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
+    log_offset: int = 0,
+    log_path: Path | None = None,
     env_override: str = "",
 ) -> None:
-    import sys
-
-    from PySide6.QtWidgets import QApplication
-
-    from emevo.analysis.qt_widget import CFEnvReplayWidget
+    from emevo.analysis.qt_widget import CFEnvReplayWidget, start_widget
 
     with cfconfig_path.open("r") as f:
         cfconfig = toml.from_toml(CfConfig, f.read())
@@ -559,17 +557,34 @@ def widget(
     cfconfig.apply_override(env_override)
     phys_state = SavedPhysicsState.load(physstate_path)
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
-    end_index = end if end is not None else phys_state.circle_axy.shape[0]
+    end = phys_state.circle_axy.shape[0] if end is None else end
+    if log_path is None:
+        log_table = None
+    else:
+        import pyarrow.dataset as ds
+
+        dataset = ds.dataset(log_path)
+        first_step = dataset.scanner(columns=["step"]).head(1)["step"][0].as_py()
+        log_start = first_step + start + log_offset
+        log_end = first_step + end + log_offset
+        scanner = dataset.scanner(
+            columns=["age", "energy", "step", "slots"],
+            filter=(ds.field("step") < log_end) & (ds.field("step") > log_start),
+        )
+        log_table = scanner.to_table()
+        log_offset = log_start
 
-    app = QApplication([])
-    widget = CFEnvReplayWidget(
-        int(cfconfig.xlim[1]),
-        int(cfconfig.ylim[1]),
-        env=env,  # type: ignore
+    start_widget(
+        CFEnvReplayWidget,
+        xlim=int(cfconfig.xlim[1]),
+        ylim=int(cfconfig.ylim[1]),
+        env=env,
         saved_physics=phys_state,
+        start=start,
+        end=end,
+        log_table=log_table,
+        log_offset=log_start,
     )
-    widget.show()
-    sys.exit(app.exec())
 
 
 if __name__ == "__main__":
diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index 68234b81..dc919dfc 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -3,10 +3,10 @@
 from __future__ import annotations
 
 import dataclasses
+import sys
 from collections import deque
 from collections.abc import Iterable
 from functools import partial
-from typing import Callable
 
 import jax
 import matplotlib as mpl
@@ -15,7 +15,6 @@
 import numpy as np
 import pyarrow as pa
 from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg
-from numpy.typing import NDArray
 from PySide6 import QtWidgets
 from PySide6.QtCharts import (
     QBarCategoryAxis,
@@ -46,13 +45,6 @@ def _mgl_qsurface_fmt() -> QSurfaceFormat:
     return fmt
 
 
-@dataclasses.dataclass
-class AppState:
-    selected: int | None = None
-    paused: bool = False
-    paused_before: bool = False
-
-
 class MglWidget(QOpenGLWidget):
     selectionChanged = Signal(int)
 
@@ -63,6 +55,10 @@ def __init__(
         env: CircleForaging,
         saved_physics: SavedPhysicsState,
         figsize: tuple[float, float],
+        start: int = 0,
+        end: int | None = None,
+        log_offset: int = 0,
+        log_table: pa.Table | None = None,
         parent: QtWidgets.QWidget | None = None,
     ) -> None:
         # Set default format
@@ -84,8 +80,11 @@ def __init__(
             stated=self._get_stated(0),
             sensor_fn=env._get_sensors,
         )
-        self._index = 0
-        self._state = AppState()
+        self._log_offset = log_offset
+        self._log_table = log_table
+        self._index = start
+        self._end_index = self._phys_state.circle_axy.shape[0] if end is None else end
+        self._paused = False
         self._initialized = False
         self._overlay_fns = []
 
@@ -124,7 +123,8 @@ def paintGL(self) -> None:
             self._fbo = self._ctx.detect_framebuffer()
             self._renderer = self._make_renderer(self._ctx)
             self._initialized = True
-        self._index += 1
+        if not self._paused and self._index < self._end_index - 1:
+            self._index += 1
         self._render(self._get_stated(self._index))
 
     def _render(self, stated: StateDict) -> None:
@@ -140,6 +140,7 @@ def _emit_selected(self, index: int | None) -> None:
 
     def mousePressEvent(self, evt: QMouseEvent) -> None:  # type: ignore
         position = self._scale_position(evt.position())
+
         # query = self._env.get_space().point_query(
         #     position,
         #     0.0,
@@ -162,11 +163,11 @@ def mouseReleaseEvent(self, evt: QMouseEvent) -> None:  # type: ignore
 
     @Slot()
     def pause(self) -> None:
-        self._state.paused = True
+        self._paused = True
 
     @Slot()
     def play(self) -> None:
-        self._state.paused = False
+        self._paused = False
 
 
 class BarChart(QtWidgets.QWidget):
@@ -275,7 +276,10 @@ def __init__(
         ylim: int,
         env: CircleForaging,
         saved_physics: SavedPhysicsState,
-        profile_and_reward: pa.Table | None = None,
+        start: int = 0,
+        end: int | None = None,
+v        log_offset: int = 0,
+        log_table: pa.Table | None = None,
     ) -> None:
         super().__init__()
 
@@ -286,6 +290,10 @@ def __init__(
             env=env,
             saved_physics=saved_physics,
             figsize=(xlim * 2, ylim * 2),
+            start=start,
+            end=end,
+            log_offset=log_offset,
+            log_table=log_table,
         )
         # Pause/Play
         self._pause_button = QtWidgets.QPushButton("⏸️")
@@ -344,3 +352,10 @@ def updateRewards(self, body_index: int) -> None:
     def change_cbar(self) -> None:
         self._showing_energy = not self._showing_energy
         self._cbar_changed = True
+
+
+def start_widget(widget_cls: type[QtWidgets.QtWidget], **kwargs) -> None:
+    app = QtWidgets.QApplication([])
+    widget = widget_cls(**kwargs)
+    widget.show()
+    sys.exit(app.exec())

From 3ca5553f75bf19d28105a26fa3a412c7783b504b Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 15 Jan 2024 01:53:33 +0900
Subject: [PATCH 196/337] mutation 02005

---
 config/gops/20240115-mutation-02005-clipped.toml | 15 +++++++++++++++
 experiments/cf_asexual_evo.py                    |  2 +-
 src/emevo/reward_fn.py                           |  6 ++++--
 3 files changed, 20 insertions(+), 3 deletions(-)
 create mode 100644 config/gops/20240115-mutation-02005-clipped.toml

diff --git a/config/gops/20240115-mutation-02005-clipped.toml b/config/gops/20240115-mutation-02005-clipped.toml
new file mode 100644
index 00000000..bdadf018
--- /dev/null
+++ b/config/gops/20240115-mutation-02005-clipped.toml
@@ -0,0 +1,15 @@
+path = "emevo.genetic_ops.BernoulliMixtureMutation"
+init_std = 0.1
+init_mean = 0.0
+
+[params]
+mutation_prob = 0.2
+
+[params.mutator]
+path = "emevo.genetic_ops.UniformMutation"
+
+[params.mutator.params]
+min_noise = -0.05
+max_noise = 0.05
+clip_min = -1.0
+clip_max = 1.0
\ No newline at end of file
diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 744aa440..80f83e90 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -406,7 +406,7 @@ def evolve(
     minibatch_size: int = 256,
     n_rollout_steps: int = 1024,
     n_total_steps: int = 1024 * 10000,
-    act_reward_coef: float = 0.01,
+    act_reward_coef: float = 0.001,
     cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
     bdconfig_path: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
     gopsconfig_path: Path = here.joinpath("../config/gops/20240111-mutation-0401.toml"),
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index ef025e61..2df8727f 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -102,8 +102,10 @@ class SigmoidReward_01(SigmoidReward):
 
     def __call__(self, *args) -> jax.Array:
         extracted, energy = self.extractor(*args)
-        energy_alpha = energy.reshape(-1, 1) * self.alpha  # (N, n_weights)
-        filtered = 2.0 * extracted / (1.0 + jnp.exp(-energy_alpha)) - (self.alpha > 0)
+        e = energy.reshape(-1, 1)  # (N, n_weights)
+        alpha_plus = 2.0 * extracted / (1.0 + jnp.exp(-e * (1.0 - self.alpha))) - 1.0
+        alpha_minus = 2.0 * extracted / (1.0 + jnp.exp(-e * self.alpha))
+        filtered = jnp.where(self.alpha > 0, alpha_plus, alpha_minus)
         return jax.vmap(jnp.dot)(filtered, self.weight)
 
 

From 1629e931db9253efaf5b3db2c30db8ede5cf2e86 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 15 Jan 2024 02:01:05 +0900
Subject: [PATCH 197/337] 2s 150 and iso 150

---
 config/env/20240115-2seasons-150.toml | 38 +++++++++++++++++++++++++++
 config/env/20240115-iso-150.toml      | 38 +++++++++++++++++++++++++++
 2 files changed, 76 insertions(+)
 create mode 100644 config/env/20240115-2seasons-150.toml
 create mode 100644 config/env/20240115-iso-150.toml

diff --git a/config/env/20240115-2seasons-150.toml b/config/env/20240115-2seasons-150.toml
new file mode 100644
index 00000000..bb8b5899
--- /dev/null
+++ b/config/env/20240115-2seasons-150.toml
@@ -0,0 +1,38 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["switching",
+       1000,
+       ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+   ]
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file
diff --git a/config/env/20240115-iso-150.toml b/config/env/20240115-iso-150.toml
new file mode 100644
index 00000000..af5f4875
--- /dev/null
+++ b/config/env/20240115-iso-150.toml
@@ -0,0 +1,38 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["gaussian-mixture",
+       [0.5, 0.5],
+       [[360.0, 270.0], [120.0, 270.0]],
+       [[48.0, 36.0], [48.0, 36.0]],
+   ]
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From c5a142de491a2d69df4d17e302c7c710af1807f1 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 15 Jan 2024 12:23:58 +0900
Subject: [PATCH 198/337] Ignore parquet and npz

---
 .gitignore | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index 6369e2f8..3203e0fa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,5 +14,5 @@ requirements/*.txt
 # This should be local
 pyrightconfig.json
 *.eqx
-# Default log dir
-log/
\ No newline at end of file
+*.parquet
+*.npz

From 0c38a4301d4a99066aa80e57997ab7ee549ba03c Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 15 Jan 2024 17:38:43 +0900
Subject: [PATCH 199/337] Read profile_and_reward in widget

---
 experiments/cf_asexual_evo.py   | 5 +++--
 src/emevo/analysis/qt_widget.py | 3 ++-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 80f83e90..7c136e2d 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -546,7 +546,8 @@ def widget(
     end: Optional[int] = None,
     cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
     log_offset: int = 0,
-    log_path: Path | None = None,
+    log_path: Optional[Path] = None,
+    profile_and_reward_path: Optional[Path] = None,
     env_override: str = "",
 ) -> None:
     from emevo.analysis.qt_widget import CFEnvReplayWidget, start_widget
@@ -583,7 +584,7 @@ def widget(
         start=start,
         end=end,
         log_table=log_table,
-        log_offset=log_start,
+        log_offset=log_offset,
     )
 
 
diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index dc919dfc..55603fe0 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -278,8 +278,9 @@ def __init__(
         saved_physics: SavedPhysicsState,
         start: int = 0,
         end: int | None = None,
-v        log_offset: int = 0,
+        log_offset: int = 0,
         log_table: pa.Table | None = None,
+        profile_and_reward: pa.Table | None = None,
     ) -> None:
         super().__init__()
 

From 27ecab936b2e60d662fc2278e736999ac745d4a8 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 15 Jan 2024 17:56:53 +0900
Subject: [PATCH 200/337] Uniform

---
 config/env/20240115-uniform-150.toml | 29 ++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 config/env/20240115-uniform-150.toml

diff --git a/config/env/20240115-uniform-150.toml b/config/env/20240115-uniform-150.toml
new file mode 100644
index 00000000..09f8fb7c
--- /dev/null
+++ b/config/env/20240115-uniform-150.toml
@@ -0,0 +1,29 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 50
+food_num_fn = ["logistic", 20, 0.01, 50]
+food_loc_fn = "uniform"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From ecfc0427e1bd6f9c7fa14cba8cc02bc79e5f7ff9 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 15 Jan 2024 18:12:54 +0900
Subject: [PATCH 201/337] Mutation 0201

---
 config/gops/20240115-mutation-0201-clipped.toml | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 config/gops/20240115-mutation-0201-clipped.toml

diff --git a/config/gops/20240115-mutation-0201-clipped.toml b/config/gops/20240115-mutation-0201-clipped.toml
new file mode 100644
index 00000000..f36238ae
--- /dev/null
+++ b/config/gops/20240115-mutation-0201-clipped.toml
@@ -0,0 +1,15 @@
+path = "emevo.genetic_ops.BernoulliMixtureMutation"
+init_std = 0.1
+init_mean = 0.0
+
+[params]
+mutation_prob = 0.2
+
+[params.mutator]
+path = "emevo.genetic_ops.UniformMutation"
+
+[params.mutator.params]
+min_noise = -0.1
+max_noise = 0.1
+clip_min = -1.0
+clip_max = 1.0
\ No newline at end of file

From a85b90b08a0a841a8f16f914332fc7ff2c7adb2e Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 15 Jan 2024 23:49:15 +0900
Subject: [PATCH 202/337] Adress ruff warnings

---
 scripts/plot_bd_models.py              | 14 ++++++--------
 src/emevo/analysis/qt_widget.py        |  1 -
 src/emevo/environments/moderngl_vis.py |  2 +-
 src/emevo/exp_utils.py                 |  2 +-
 src/emevo/visualizer.py                |  2 +-
 5 files changed, 9 insertions(+), 12 deletions(-)

diff --git a/scripts/plot_bd_models.py b/scripts/plot_bd_models.py
index 6e67a1a3..6d4fb1f8 100644
--- a/scripts/plot_bd_models.py
+++ b/scripts/plot_bd_models.py
@@ -1,3 +1,4 @@
+import importlib
 from pathlib import Path
 
 import matplotlib as mpl
@@ -33,11 +34,9 @@ def plot_bd_models(
     simpletitle: bool = typer.Option(False, help="Make title simple"),
     birth2d: bool = typer.Option(False, help="Make 2D plot for birth rate"),
 ) -> None:
-    try:
-        import PySide6
-
+    if importlib.util.find_spec("PySide6") is not None:
         mpl.use("QtAgg")
-    except ImportError:
+    else:
         mpl.use("TkAgg")
 
     with config.open("r") as f:
@@ -85,7 +84,7 @@ def plot_bd_models(
         else:
             ax = fig.add_subplot(111, projection="3d")
         if simpletitle:
-            ax.set_title(f"Birth function")  # type: ignore
+            ax.set_title("Birth function")  # type: ignore
         else:
             ax.set_title(f"{type(birth_model).__name__} Birth function")  # type: ignore
         if birth2d:
@@ -110,9 +109,8 @@ def plot_bd_models(
     if yes or typer.confirm("Plot survivor ship curve?"):
         fig = plt.figure(figsize=(5, 10))
         ax = fig.add_subplot(111)
-        ax.set_title(
-            f"{type(birth_model).__name__} Survivor ship when energy={survivorship_energy}"
-        )
+        tname = type(birth_model).__name__
+        ax.set_title(f"{tname} Survivor ship when energy={survivorship_energy}")
         vis_survivorship(ax=ax, hazard_fn=hazard_model, age_max=age_max, initial=True)
         plt.show()
 
diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index 55603fe0..64358a61 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -2,7 +2,6 @@
 """
 from __future__ import annotations
 
-import dataclasses
 import sys
 from collections import deque
 from collections.abc import Iterable
diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index 8d78f864..d2787c45 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -4,7 +4,7 @@
 """
 from __future__ import annotations
 
-from typing import Any, Callable, ClassVar
+from typing import Callable, ClassVar
 
 import jax.numpy as jnp
 import moderngl as mgl
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index e2f4a3f9..43e99367 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -333,7 +333,7 @@ def finalize(self) -> None:
             ]
             pq.write_table(
                 pa.Table.from_pylist(profile_and_rewards),
-                self.logdir.joinpath(f"profile_and_rewards.parquet"),
+                self.logdir.joinpath("profile_and_rewards.parquet"),
             )
 
         if self.mode in [LogMode.FULL, LogMode.REWARD_AND_LOG]:
diff --git a/src/emevo/visualizer.py b/src/emevo/visualizer.py
index 4508d906..2ec6945c 100644
--- a/src/emevo/visualizer.py
+++ b/src/emevo/visualizer.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from os import PathLike
-from typing import Any, Protocol, TypeVar
+from typing import Protocol, TypeVar
 
 from numpy.typing import NDArray
 

From af1199c184143c21891bbb2f9ba40be476ebdb5d Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 16 Jan 2024 02:04:40 +0900
Subject: [PATCH 203/337] Some more configs

---
 config/env/20240116-2s-150-interval100.toml | 38 +++++++++++++++++++
 config/env/20240116-food-cycle-1.toml       | 41 +++++++++++++++++++++
 config/env/20240116-food-cycle-2.toml       | 41 +++++++++++++++++++++
 3 files changed, 120 insertions(+)
 create mode 100644 config/env/20240116-2s-150-interval100.toml
 create mode 100644 config/env/20240116-food-cycle-1.toml
 create mode 100644 config/env/20240116-food-cycle-2.toml

diff --git a/config/env/20240116-2s-150-interval100.toml b/config/env/20240116-2s-150-interval100.toml
new file mode 100644
index 00000000..9e5ade40
--- /dev/null
+++ b/config/env/20240116-2s-150-interval100.toml
@@ -0,0 +1,38 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["switching",
+       100,
+       ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+   ]
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file
diff --git a/config/env/20240116-food-cycle-1.toml b/config/env/20240116-food-cycle-1.toml
new file mode 100644
index 00000000..e223c343
--- /dev/null
+++ b/config/env/20240116-food-cycle-1.toml
@@ -0,0 +1,41 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+n_max_foods = 60
+food_num_fn = [
+   "scheduled",
+   1024000,
+   ["logistic", 20, 0.01, 60],
+   ["logistic", 20, 0.01, 50],
+   ["logistic", 20, 0.01, 40],
+   ["logistic", 20, 0.01, 50],
+   ["logistic", 20, 0.01, 60],
+   ["logistic", 20, 0.01, 50],
+   ["logistic", 20, 0.01, 40],
+   ["logistic", 20, 0.01, 50],
+   ["logistic", 20, 0.01, 60],
+   ["logistic", 20, 0.01, 50],
+]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file
diff --git a/config/env/20240116-food-cycle-2.toml b/config/env/20240116-food-cycle-2.toml
new file mode 100644
index 00000000..431418c8
--- /dev/null
+++ b/config/env/20240116-food-cycle-2.toml
@@ -0,0 +1,41 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+n_max_foods = 60
+food_num_fn = [
+   "scheduled",
+   1024000,
+   ["logistic", 20, 0.01, 40],
+   ["logistic", 20, 0.01, 50],
+   ["logistic", 20, 0.01, 60],
+   ["logistic", 20, 0.01, 50],
+   ["logistic", 20, 0.01, 40],
+   ["logistic", 20, 0.01, 50],
+   ["logistic", 20, 0.01, 60],
+   ["logistic", 20, 0.01, 50],
+   ["logistic", 20, 0.01, 40],
+   ["logistic", 20, 0.01, 50],
+]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 03d2bb1ff37f86594b63315b85ae1e66cd3acab1 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 16 Jan 2024 02:28:45 +0900
Subject: [PATCH 204/337] Fix bug in food-cycle

---
 config/env/20240116-food-cycle-1.toml | 1 -
 config/env/20240116-food-cycle-2.toml | 1 -
 2 files changed, 2 deletions(-)

diff --git a/config/env/20240116-food-cycle-1.toml b/config/env/20240116-food-cycle-1.toml
index e223c343..213036f0 100644
--- a/config/env/20240116-food-cycle-1.toml
+++ b/config/env/20240116-food-cycle-1.toml
@@ -1,7 +1,6 @@
 n_initial_agents = 50
 n_max_agents = 150
 n_max_foods = 60
-n_max_foods = 60
 food_num_fn = [
    "scheduled",
    1024000,
diff --git a/config/env/20240116-food-cycle-2.toml b/config/env/20240116-food-cycle-2.toml
index 431418c8..10ea9902 100644
--- a/config/env/20240116-food-cycle-2.toml
+++ b/config/env/20240116-food-cycle-2.toml
@@ -1,7 +1,6 @@
 n_initial_agents = 50
 n_max_agents = 150
 n_max_foods = 60
-n_max_foods = 60
 food_num_fn = [
    "scheduled",
    1024000,

From db3667ea80e9294b942ed0e89c53adb843303a5c Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 16 Jan 2024 20:14:01 +0900
Subject: [PATCH 205/337] Show age/energy/n_children in widget

---
 experiments/cf_asexual_evo.py          |  24 +--
 src/emevo/analysis/qt_widget.py        | 249 +++++++++++++++++--------
 src/emevo/environments/moderngl_vis.py |  37 +++-
 src/emevo/visualizer.py                |   4 +-
 4 files changed, 217 insertions(+), 97 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 7c136e2d..091336de 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -547,7 +547,7 @@ def widget(
     cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
     log_offset: int = 0,
     log_path: Optional[Path] = None,
-    profile_and_reward_path: Optional[Path] = None,
+    profile_and_rewards_path: Optional[Path] = None,
     env_override: str = "",
 ) -> None:
     from emevo.analysis.qt_widget import CFEnvReplayWidget, start_widget
@@ -560,21 +560,22 @@ def widget(
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
     end = phys_state.circle_axy.shape[0] if end is None else end
     if log_path is None:
-        log_table = None
+        log_ds = None
     else:
         import pyarrow.dataset as ds
 
-        dataset = ds.dataset(log_path)
-        first_step = dataset.scanner(columns=["step"]).head(1)["step"][0].as_py()
+        log_ds = ds.dataset(log_path)
+        first_step = log_ds.scanner(columns=["step"]).head(1)["step"][0].as_py()
         log_start = first_step + start + log_offset
-        log_end = first_step + end + log_offset
-        scanner = dataset.scanner(
-            columns=["age", "energy", "step", "slots"],
-            filter=(ds.field("step") < log_end) & (ds.field("step") > log_start),
-        )
-        log_table = scanner.to_table()
         log_offset = log_start
 
+    if profile_and_rewards_path is None:
+        profile_and_rewards = None
+    else:
+        import pyarrow.parquet as pq
+
+        profile_and_rewards = pq.read_table(profile_and_rewards_path)
+
     start_widget(
         CFEnvReplayWidget,
         xlim=int(cfconfig.xlim[1]),
@@ -583,8 +584,9 @@ def widget(
         saved_physics=phys_state,
         start=start,
         end=end,
-        log_table=log_table,
+        log_ds=log_ds,
         log_offset=log_offset,
+        profile_and_rewards=profile_and_rewards,
     )
 
 
diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index 64358a61..e988881c 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -2,18 +2,26 @@
 """
 from __future__ import annotations
 
+import enum
+import functools
 import sys
+import warnings
 from collections import deque
 from collections.abc import Iterable
 from functools import partial
+from typing import Callable
 
 import jax
+import jax.numpy as jnp
 import matplotlib as mpl
 import matplotlib.colors as mc
 import moderngl
 import numpy as np
 import pyarrow as pa
+import pyarrow.compute as pc
+import pyarrow.dataset as ds
 from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg
+from numpy.typing import NDArray
 from PySide6 import QtWidgets
 from PySide6.QtCharts import (
     QBarCategoryAxis,
@@ -29,7 +37,7 @@
 
 from emevo.environments.circle_foraging import CircleForaging
 from emevo.environments.moderngl_vis import MglRenderer
-from emevo.environments.phyjax2d import StateDict
+from emevo.environments.phyjax2d import Circle, State, StateDict
 from emevo.exp_utils import SavedPhysicsState
 from emevo.plotting import CBarRenderer
 
@@ -44,6 +52,15 @@ def _mgl_qsurface_fmt() -> QSurfaceFormat:
     return fmt
 
 
+N_MAX_SCAN: int = 10000
+
+
+@jax.jit
+def _overlap(p: jax.Array, circle: Circle, state: State) -> jax.Array:
+    dist = jnp.linalg.norm(p.reshape(1, 2) - state.p.xy, axis=1)
+    return dist < circle.radius
+
+
 class MglWidget(QOpenGLWidget):
     selectionChanged = Signal(int)
 
@@ -56,8 +73,7 @@ def __init__(
         figsize: tuple[float, float],
         start: int = 0,
         end: int | None = None,
-        log_offset: int = 0,
-        log_table: pa.Table | None = None,
+        get_colors: Callable[[int], NDArray] | None = None,
         parent: QtWidgets.QWidget | None = None,
     ) -> None:
         # Set default format
@@ -79,13 +95,14 @@ def __init__(
             stated=self._get_stated(0),
             sensor_fn=env._get_sensors,
         )
-        self._log_offset = log_offset
-        self._log_table = log_table
+        self._env = env
+        self._get_colors = get_colors
         self._index = start
         self._end_index = self._phys_state.circle_axy.shape[0] if end is None else end
         self._paused = False
         self._initialized = False
         self._overlay_fns = []
+        self._showing_energy = False
 
         # Set timer
         self._timer = timer
@@ -118,47 +135,32 @@ def paintGL(self) -> None:
             else:
                 self._ctx = moderngl.create_context(require=410)
             if self._ctx.error != "GL_NO_ERROR":
-                raise RuntimeError(f"The following error occured: {self._ctx.error}")
+                warnings.warn(f"The qfollowing error occured: {self._ctx.error}")
             self._fbo = self._ctx.detect_framebuffer()
             self._renderer = self._make_renderer(self._ctx)
             self._initialized = True
         if not self._paused and self._index < self._end_index - 1:
             self._index += 1
-        self._render(self._get_stated(self._index))
-
-    def _render(self, stated: StateDict) -> None:
+        stated = self._get_stated(self._index)
+        if self._get_colors is None:
+            circle_colors = None
+        else:
+            circle_colors = self._get_colors(self._index)
         self._fbo.use()
         self._ctx.clear(1.0, 1.0, 1.0)
-        self._renderer.render(stated)  # type: ignore
-
-    def _emit_selected(self, index: int | None) -> None:
-        if index is None:
-            self.selectionChanged.emit(-1)
-        else:
-            self.selectionChanged.emit(index)
+        self._renderer.render(stated, circle_colors=circle_colors)  # type: ignore
 
     def mousePressEvent(self, evt: QMouseEvent) -> None:  # type: ignore
         position = self._scale_position(evt.position())
-
-        # query = self._env.get_space().point_query(
-        #     position,
-        #     0.0,
-        #     shape_filter=make_filter(CollisionType.AGENT, CollisionType.FOOD),
-        # )
-        # if len(query) == 1:
-        #     shape = query[0].shape
-        #     if shape is not None:
-        #         body_index = self._env.get_body_index(shape.body)
-        #         if body_index is not None:
-        #             self._state.pantool.start_drag(position, shape, body_index)
-        #             self._emit_selected(body_index)
-        #             self._paused_before = self._state.paused
-        #             self._state.paused = True
-        #             self._timer.stop()
-        #             self.update()
-
-    def mouseReleaseEvent(self, evt: QMouseEvent) -> None:  # type: ignore
-        pass
+        circle = self._get_stated(self._index).circle
+        overlap = _overlap(
+            jnp.array(position),
+            self._env._physics.shaped.circle,
+            circle,
+        )
+        (selected,) = jnp.nonzero(overlap)
+        if 0 < selected.shape[0]:
+            self.selectionChanged.emit(selected[0].item())
 
     @Slot()
     def pause(self) -> None:
@@ -227,7 +229,7 @@ def _make_barset(self, name: str, value: float | list[float]) -> QBarSet:
             for v in value:
                 barset.append(v)
         else:
-            raise ValueError(f"Invalid value for barset: {value}")
+            warnings.warn(f"Invalid value for barset: {value}")
         self.barsets[name] = barset
         self.series.append(barset)
         return barset
@@ -253,7 +255,7 @@ def updateValues(self, values: dict[str, float | list[float]]) -> None:
                 for i, vi in enumerate(value):
                     self.barsets[name].replace(i, vi)
             else:
-                raise ValueError(f"Invalid value for barset {value}")
+                warnings.warn(f"Invalid value for barset {value}")
 
         for name in list(self.barsets.keys()):
             if name not in values:
@@ -263,11 +265,15 @@ def updateValues(self, values: dict[str, float | list[float]]) -> None:
         self._update_yrange(values.values())
 
 
+class CBarState(enum.Enum):
+    AGE = 1
+    ENERGY = 2
+    N_CHILDREN = 3
+
+
 class CFEnvReplayWidget(QtWidgets.QWidget):
     energyUpdated = Signal(float)
     rewardUpdated = Signal(dict)
-    foodrankUpdated = Signal(dict)
-    valueUpdated = Signal(float)
 
     def __init__(
         self,
@@ -278,8 +284,8 @@ def __init__(
         start: int = 0,
         end: int | None = None,
         log_offset: int = 0,
-        log_table: pa.Table | None = None,
-        profile_and_reward: pa.Table | None = None,
+        log_ds: ds.Dataset | None = None,
+        profile_and_rewards: pa.Table | None = None,
     ) -> None:
         super().__init__()
 
@@ -292,38 +298,52 @@ def __init__(
             figsize=(xlim * 2, ylim * 2),
             start=start,
             end=end,
-            log_offset=log_offset,
-            log_table=log_table,
+            get_colors=None if log_ds is None else self._get_colors,
         )
+        self._n_max_agents = env.n_max_agents
+        # Log
+        self._log_offset = log_offset
+        self._log_ds = log_ds
+        self._log_cached = []
         # Pause/Play
-        self._pause_button = QtWidgets.QPushButton("⏸️")
-        self._pause_button.clicked.connect(self._mgl_widget.pause)
-        self._play_button = QtWidgets.QPushButton("▶️")
-        self._play_button.clicked.connect(self._mgl_widget.play)
-        self._cbar_select_button = QtWidgets.QPushButton("Switch Value/Energy")
-        self._cbar_select_button.clicked.connect(self.change_cbar)
+        pause_button = QtWidgets.QPushButton("⏸️")
+        pause_button.clicked.connect(self._mgl_widget.pause)
+        play_button = QtWidgets.QPushButton("▶️")
+        play_button.clicked.connect(self._mgl_widget.play)
         # Colorbar
+        radiobutton_1 = QtWidgets.QRadioButton("Age")
+        radiobutton_2 = QtWidgets.QRadioButton("Energy")
+        radiobutton_3 = QtWidgets.QRadioButton("Num. Children")
+        radiobutton_1.setChecked(True)
+        radiobutton_1.toggled.connect(self.cbarAge)
+        radiobutton_2.toggled.connect(self.cbarEnergy)
+        radiobutton_3.toggled.connect(self.cbarNChildren)
+        self._cbar_state = CBarState.AGE
         self._cbar_renderer = CBarRenderer(xlim * 2, ylim // 4)
         self._showing_energy = True
         self._cbar_changed = True
         self._cbar_canvas = FigureCanvasQTAgg(self._cbar_renderer._fig)
         self._value_cm = mpl.colormaps["YlOrRd"]
         self._energy_cm = mpl.colormaps["YlGnBu"]
+        self._n_children_cm = mpl.colormaps["PuBuGn"]
         self._norm = mc.Normalize(vmin=0.0, vmax=1.0)
-        if profile_and_reward is not None:
-            self._reward_widget = BarChart(
-                next(iter(self._rewards.values())).to_pydict()
-            )
+        if profile_and_rewards is not None:
+            self._profile_and_rewards = profile_and_rewards
+            self._reward_widget = BarChart(self._get_rewards(1))
         # Layout buttons
         buttons = QtWidgets.QHBoxLayout()
-        buttons.addWidget(self._pause_button)
-        buttons.addWidget(self._play_button)
-        buttons.addWidget(self._cbar_select_button)
+        buttons.addWidget(pause_button)
+        buttons.addWidget(play_button)
+        cbar_selector = QtWidgets.QVBoxLayout()
+        cbar_selector.addWidget(radiobutton_1)
+        cbar_selector.addWidget(radiobutton_2)
+        cbar_selector.addWidget(radiobutton_3)
+        buttons.addLayout(cbar_selector)
         # Total layout
         total_layout = QtWidgets.QVBoxLayout()
         total_layout.addLayout(buttons)
         total_layout.addWidget(self._cbar_canvas)
-        if profile_and_reward is None:
+        if profile_and_rewards is None:
             total_layout.addWidget(self._mgl_widget)
         else:
             env_and_reward_layout = QtWidgets.QHBoxLayout()
@@ -332,29 +352,108 @@ def __init__(
             total_layout.addLayout(env_and_reward_layout)
         self.setLayout(total_layout)
         timer.start(30)  # 40fps
-        self._arrow_cached = None
-        self._obs_cached = {}
         # Signals
         self._mgl_widget.selectionChanged.connect(self.updateRewards)
-        if profile_and_reward is not None:
+        if profile_and_rewards is not None:
             self.rewardUpdated.connect(self._reward_widget.updateValues)
         # Initial size
-        self.resize(xlim * 3, int(ylim * 2.4))
+        if profile_and_rewards is None:
+            self.resize(xlim * 3, ylim * 3)
+        else:
+            self.resize(xlim * 4, ylim * 3)
+
+    def _get_rewards(self, unique_id: int) -> dict[str, float]:
+        filtered = self._profile_and_rewards.filter(pc.field("unique_id") == unique_id)
+        return filtered.drop(["birthtime", "parent", "unique_id"]).to_pydict()
+
+    @functools.cache
+    def _get_n_children(self, unique_id: int) -> int:
+        if self._profile_and_rewards is None:
+            warnings.warn("N children requires profile_an_rewards.parquet")
+            return 0
+        if unique_id == 0:
+            return 0
+        return len(self._profile_and_rewards.filter(pc.field("parent") == unique_id))
+
+    def _get_colors(self, index: int) -> NDArray:
+        assert self._log_ds is not None
+        step = self._log_offset + index
+        if len(self._log_cached) == 0:
+            scanner = self._log_ds.scanner(
+                columns=["age", "energy", "step", "slots", "unique_id"],
+                filter=(
+                    (step <= pc.field("step")) & (pc.field("step") <= step + N_MAX_SCAN)
+                ),
+            )
+            table = scanner.to_table()
+            self._log_cached = [
+                table.filter(pc.field("step") == i).to_pydict()
+                for i in reversed(range(step, step + N_MAX_SCAN))
+            ]
+        log = self._log_cached.pop()
+        slots = np.array(log["slots"])
+        if self._cbar_state is CBarState.AGE:
+            title = "Age"
+            cm = self._value_cm
+            age = np.array(log["age"])
+            value = np.ones(self._n_max_agents) * np.min(age)
+            value[slots] = age
+        elif self._cbar_state is CBarState.ENERGY:
+            title = "Energy"
+            cm = self._energy_cm
+            energy = np.array(log["energy"])
+            value = np.ones(self._n_max_agents) * np.min(energy)
+            value[slots] = energy
+        elif self._cbar_state is CBarState.N_CHILDREN:
+            title = "Num. Children"
+            cm = self._n_children_cm
+            value = np.zeros(self._n_max_agents)
+            for slot, uid in zip(log["slots"], log["unique_id"]):
+                value[slot] = self._get_n_children(uid)
+        else:
+            warnings.warn(f"Invalid cbar state {self._cbar_state}")
+            return np.zeros((self._n_max_agents, 4))
+        self._norm.vmin = np.amin(value)  # type: ignore
+        self._norm.vmax = np.amax(value)  # type: ignore
+        if self._cbar_changed:
+            self._cbar_renderer.render(self._norm, cm, title)
+            self._cbar_changed = False
+            self._cbar_canvas.draw()
+        return cm(self._norm(value))
 
     @Slot(int)
-    def updateRewards(self, body_index: int) -> None:
-        pass
-        # if self._rewards is None or body_index == -1:
-        #     return
-        # self.rewardUpdated.emit(self._rewards[body_index].to_pydict())
-
-    @Slot()
-    def change_cbar(self) -> None:
-        self._showing_energy = not self._showing_energy
-        self._cbar_changed = True
-
-
-def start_widget(widget_cls: type[QtWidgets.QtWidget], **kwargs) -> None:
+    def updateRewards(self, selected_slot: int) -> None:
+        if self._profile_and_rewards is None or selected_slot == -1:
+            return
+
+        if len(self._log_cached) == 0:
+            return
+        last_log = self._log_cached[-1]
+        for slot, uid in zip(last_log["slots"], last_log["unique_id"]):
+            if slot == selected_slot:
+                self.rewardUpdated.emit(self._get_rewards(uid))
+                return
+
+    @Slot(bool)
+    def cbarAge(self, checked: bool) -> None:
+        if checked:
+            self._cbar_state = CBarState.AGE
+            self._cbar_changed = True
+
+    @Slot(bool)
+    def cbarEnergy(self, checked: bool) -> None:
+        if checked:
+            self._cbar_state = CBarState.ENERGY
+            self._cbar_changed = True
+
+    @Slot(bool)
+    def cbarNChildren(self, checked: bool) -> None:
+        if checked:
+            self._cbar_state = CBarState.N_CHILDREN
+            self._cbar_changed = True
+
+
+def start_widget(widget_cls: type[QtWidgets.QWidget], **kwargs) -> None:
     app = QtWidgets.QApplication([])
     widget = widget_cls(**kwargs)
     widget.show()
diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index d2787c45..04f67ddf 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -15,7 +15,6 @@
 
 from emevo.environments.phyjax2d import Circle, Segment, Space, State, StateDict
 
-
 NOWHERE: float = -1000.0
 
 
@@ -441,21 +440,41 @@ def _make_gl_program(
             prog[key].write(value)  # type: ignore
         return prog
 
+    @staticmethod
+    def _get_colors(default_colors: NDArray, colors: NDArray | None) -> NDArray:
+        if colors is None:
+            return default_colors
+        else:
+            clen = colors.shape[0]
+            if clen < default_colors.shape[0]:
+                return np.concatenate(
+                    (colors.astype(np.float32), default_colors[clen:]),
+                    axis=0,
+                )
+            else:
+                return colors.astype(np.float32)
 
-    def render(self, stated: StateDict) -> None:
-        circles = _collect_circles(
+    def render(
+        self,
+        stated: StateDict,
+        circle_colors: NDArray | None = None,
+        sc_colors: NDArray | None = None,
+    ) -> None:
+        circle_points, circle_scale, circle_colors_default = _collect_circles(
             self._space.shaped.circle,
             stated.circle,
             self._circle_scaling,
         )
-        static_circles = _collect_circles(
+        circle_colors = self._get_colors(circle_colors_default, circle_colors)
+        if self._circles.update(circle_points, circle_scale, circle_colors):
+            self._circles.render()
+        sc_points, sc_scale, sc_colors_default = _collect_circles(
             self._space.shaped.static_circle,
             stated.static_circle,
             self._circle_scaling,
         )
-        if self._circles.update(*circles):
-            self._circles.render()
-        if self._static_circles.update(*static_circles):
+        sc_colors = self._get_colors(sc_colors_default, sc_colors)
+        if self._static_circles.update(sc_points, sc_scale, sc_colors):
             self._static_circles.render()
         if self._sensors is not None and self._collect_sensors is not None:
             if self._sensors.update(self._collect_sensors(stated)):
@@ -522,10 +541,10 @@ def get_image(self) -> NDArray:
         w, h = self._figsize
         return output.reshape(h, w, -1)[::-1]
 
-    def render(self, state: StateDict) -> None:
+    def render(self, state: StateDict, **kwargs) -> None:
         self._window.clear(1.0, 1.0, 1.0)
         self._window.use()
-        self._renderer.render(stated=state)
+        self._renderer.render(stated=state, **kwargs)
 
     def show(self) -> None:
         self._window.swap_buffers()
diff --git a/src/emevo/visualizer.py b/src/emevo/visualizer.py
index 2ec6945c..a1c863d8 100644
--- a/src/emevo/visualizer.py
+++ b/src/emevo/visualizer.py
@@ -16,7 +16,7 @@ def close(self) -> None:
     def get_image(self) -> NDArray:
         ...
 
-    def render(self, state: STATE) -> None:
+    def render(self, state: STATE, **kwargs) -> None:
         """Render image"""
         ...
 
@@ -34,7 +34,7 @@ def close(self) -> None:
     def get_image(self) -> NDArray:
         return self.unwrapped.get_image()
 
-    def render(self, state: STATE) -> None:
+    def render(self, state: STATE, **kwargs) -> None:
         self.unwrapped.render(state)
 
     def show(self) -> None:

From de535f93af1c4d786fd7d09ed25005b14557e7fd Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 17 Jan 2024 12:08:16 +0900
Subject: [PATCH 206/337] Fix size of cycle 1/2

---
 config/env/20240116-food-cycle-1.toml | 2 ++
 config/env/20240116-food-cycle-2.toml | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/config/env/20240116-food-cycle-1.toml b/config/env/20240116-food-cycle-1.toml
index 213036f0..220aa004 100644
--- a/config/env/20240116-food-cycle-1.toml
+++ b/config/env/20240116-food-cycle-1.toml
@@ -15,6 +15,8 @@ food_num_fn = [
    ["logistic", 20, 0.01, 60],
    ["logistic", 20, 0.01, 50],
 ]
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
 food_loc_fn = "gaussian"
 agent_loc_fn = "uniform"
 env_shape = "square"
diff --git a/config/env/20240116-food-cycle-2.toml b/config/env/20240116-food-cycle-2.toml
index 10ea9902..cef502e9 100644
--- a/config/env/20240116-food-cycle-2.toml
+++ b/config/env/20240116-food-cycle-2.toml
@@ -15,6 +15,8 @@ food_num_fn = [
    ["logistic", 20, 0.01, 40],
    ["logistic", 20, 0.01, 50],
 ]
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
 food_loc_fn = "gaussian"
 agent_loc_fn = "uniform"
 env_shape = "square"

From 73c9d81a07f31c5313e29e2e832de9401d8cdfff Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 18 Jan 2024 14:42:02 +0900
Subject: [PATCH 207/337] Exponential reward

---
 src/emevo/reward_fn.py | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 2df8727f..4316ddb2 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -63,6 +63,37 @@ def __call__(self, *args) -> jax.Array:
     def serialise(self) -> dict[str, float | NDArray]:
         return jax.tree_map(_item_or_np, self.serializer(self.weight))
 
+class ExponentialReward(RewardFn):
+    weight: jax.Array
+    alpha: jax.Array
+    extractor: Callable[..., tuple[jax.Array, jax.Array]]
+    serializer: Callable[[jax.Array, jax.Array], dict[str, jax.Array]]
+
+    def __init__(
+        self,
+        *,
+        key: chex.PRNGKey,
+        n_agents: int,
+        n_weights: int,
+        extractor: Callable[..., tuple[jax.Array, jax.Array]],
+        serializer: Callable[[jax.Array, jax.Array], dict[str, jax.Array]],
+        std: float = 1.0,
+        mean: float = 0.0,
+    ) -> None:
+        k1, k2 = jax.random.split(key)
+        self.weight = jax.random.normal(k1, (n_agents, n_weights)) * std + mean
+        self.scale = jax.random.normal(k2, (n_agents, n_weights)) * std + mean
+        self.extractor = extractor
+        self.serializer = serializer
+
+    def __call__(self, *args) -> jax.Array:
+        extracted = self.extractor(*args)
+        weight = (10 ** self.scale) * self.weight
+        return jax.vmap(jnp.dot)(extracted, weight)
+
+    def serialise(self) -> dict[str, float | NDArray]:
+        return jax.tree_map(_item_or_np, self.serializer(self.weight, self.scale))
+
 
 class SigmoidReward(RewardFn):
     weight: jax.Array

From 271214181de47908a33f679dd988584d98d9fae8 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 18 Jan 2024 17:02:19 +0900
Subject: [PATCH 208/337] Test exponential rewards

---
 experiments/cf_asexual_evo.py | 48 +++++++++++++++++++----------------
 src/emevo/exp_utils.py        | 17 +++++++------
 src/emevo/reward_fn.py        | 17 ++++++++++---
 3 files changed, 48 insertions(+), 34 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 091336de..f913d8dd 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -33,11 +33,13 @@
     SavedProfile,
 )
 from emevo.reward_fn import (
+    ExponentialReward,
     LinearReward,
     RewardFn,
     SigmoidReward,
     SigmoidReward_01,
     mutate_reward_fn,
+    serialize_weight,
 )
 from emevo.rl.ppo_normal import (
     NormalPPONet,
@@ -54,6 +56,7 @@
 
 class RewardKind(str, enum.Enum):
     LINEAR = "linear"
+    EXPONENTIAL = "exponential"
     SIGMOID = "sigmoid"
     SIGMOID_01 = "sigmoid-01"
 
@@ -94,30 +97,22 @@ def extract_sigmoid(
         return jnp.concatenate((collision, act_input), axis=1), energy
 
 
-def slice_last(w: jax.Array, i: int) -> jax.Array:
-    return jnp.squeeze(jax.lax.slice_in_dim(w, i, i + 1, axis=-1))
-
-
-def linear_reward_serializer(w: jax.Array) -> dict[str, jax.Array]:
-    return {
-        "agent": slice_last(w, 0),
-        "food": slice_last(w, 1),
-        "wall": slice_last(w, 2),
-        "action": slice_last(w, 3),
-    }
+def exp_reward_serializer(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
+    w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    scale_dict = serialize_weight(
+        scale,
+        ["scale_agent", "scale_food", "scale_wall", "scale_action"],
+    )
+    return w_dict | scale_dict
 
 
 def sigmoid_reward_serializer(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
-    return {
-        "w_agent": slice_last(w, 0),
-        "w_food": slice_last(w, 1),
-        "w_wall": slice_last(w, 2),
-        "w_action": slice_last(w, 3),
-        "alpha_agent": slice_last(alpha, 0),
-        "alpha_food": slice_last(alpha, 1),
-        "alpha_wall": slice_last(alpha, 2),
-        "alpha_action": slice_last(alpha, 3),
-    }
+    w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    alpha_dict = serialize_weight(
+        alpha,
+        ["alpha_agent", "alpha_food", "alpha_wall", "alpha_action"],
+    )
+    return w_dict | alpha_dict
 
 
 def exec_rollout(
@@ -459,7 +454,16 @@ def evolve(
         reward_fn_instance = LinearReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_linear,
-            serializer=linear_reward_serializer,
+            serializer=lambda w: serialize_weight(
+                w,
+                ["agent", "food", "wall", "action"],
+            ),
+        )
+    elif reward_fn == RewardKind.EXPONENTIAL:
+        reward_fn_instance = ExponentialReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_linear,
+            serializer=exp_reward_serializer,
         )
     elif reward_fn == RewardKind.SIGMOID:
         reward_fn_instance = SigmoidReward(
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 43e99367..dd8d483c 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -325,16 +325,17 @@ def save_agents(
             modelpath = self.logdir.joinpath(f"trained-{uid}.eqx")
             eqx.tree_serialise_leaves(modelpath, sliced_net)
 
+    def save_profile_and_rewards(self) -> None:
+        profile_and_rewards = [
+            v.serialise() | dataclasses.asdict(self.profile_dict[k])
+            for k, v in self.reward_fn_dict.items()
+        ]
+        table = pa.Table.from_pylist(profile_and_rewards)
+        pq.write_table(table, self.logdir.joinpath("profile_and_rewards.parquet"))
+
     def finalize(self) -> None:
         if self.mode != LogMode.NONE:
-            profile_and_rewards = [
-                v.serialise() | dataclasses.asdict(self.profile_dict[k])
-                for k, v in self.reward_fn_dict.items()
-            ]
-            pq.write_table(
-                pa.Table.from_pylist(profile_and_rewards),
-                self.logdir.joinpath("profile_and_rewards.parquet"),
-            )
+            self.save_profile_and_rewards()
 
         if self.mode in [LogMode.FULL, LogMode.REWARD_AND_LOG]:
             self._save_log()
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 4316ddb2..f70979da 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -36,6 +36,14 @@ def _item_or_np(array: jax.Array) -> float | NDArray:
         return np.array(array)
 
 
+def slice_last(w: jax.Array, i: int) -> jax.Array:
+    return jnp.squeeze(jax.lax.slice_in_dim(w, i, i + 1, axis=-1))
+
+
+def serialize_weight(w: jax.Array, keys: list[str]) -> dict[str, jax.Array]:
+    return {key: slice_last(w, i) for i, key in enumerate(keys)}
+
+
 class LinearReward(RewardFn):
     weight: jax.Array
     extractor: Callable[..., jax.Array]
@@ -63,10 +71,11 @@ def __call__(self, *args) -> jax.Array:
     def serialise(self) -> dict[str, float | NDArray]:
         return jax.tree_map(_item_or_np, self.serializer(self.weight))
 
+
 class ExponentialReward(RewardFn):
     weight: jax.Array
-    alpha: jax.Array
-    extractor: Callable[..., tuple[jax.Array, jax.Array]]
+    scale: jax.Array
+    extractor: Callable[..., jax.Array]
     serializer: Callable[[jax.Array, jax.Array], dict[str, jax.Array]]
 
     def __init__(
@@ -75,7 +84,7 @@ def __init__(
         key: chex.PRNGKey,
         n_agents: int,
         n_weights: int,
-        extractor: Callable[..., tuple[jax.Array, jax.Array]],
+        extractor: Callable[..., jax.Array],
         serializer: Callable[[jax.Array, jax.Array], dict[str, jax.Array]],
         std: float = 1.0,
         mean: float = 0.0,
@@ -88,7 +97,7 @@ def __init__(
 
     def __call__(self, *args) -> jax.Array:
         extracted = self.extractor(*args)
-        weight = (10 ** self.scale) * self.weight
+        weight = (10**self.scale) * self.weight
         return jax.vmap(jnp.dot)(extracted, weight)
 
     def serialise(self) -> dict[str, float | NDArray]:

From 66fe136ec5d6aa985322adafa2fce6db3ac89d2e Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Thu, 18 Jan 2024 17:15:46 +0900
Subject: [PATCH 209/337] 150-60

---
 config/env/20240118-square-150-60.toml  | 29 +++++++++++++++++++++++++
 config/env/20240118-uniform-150-60.toml | 29 +++++++++++++++++++++++++
 2 files changed, 58 insertions(+)
 create mode 100644 config/env/20240118-square-150-60.toml
 create mode 100644 config/env/20240118-uniform-150-60.toml

diff --git a/config/env/20240118-square-150-60.toml b/config/env/20240118-square-150-60.toml
new file mode 100644
index 00000000..8fd62edc
--- /dev/null
+++ b/config/env/20240118-square-150-60.toml
@@ -0,0 +1,29 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file
diff --git a/config/env/20240118-uniform-150-60.toml b/config/env/20240118-uniform-150-60.toml
new file mode 100644
index 00000000..7d1b7681
--- /dev/null
+++ b/config/env/20240118-uniform-150-60.toml
@@ -0,0 +1,29 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = "uniform"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 0fda052f8cc005ae93015108de5a444e1f137d38 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 19 Jan 2024 01:27:17 +0900
Subject: [PATCH 210/337] Convert log and physics state to NumPy to save memory

---
 src/emevo/exp_utils.py | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 43e99367..0b618965 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -194,15 +194,6 @@ class SavedPhysicsState:
     static_circle_axy: jax.Array
     static_circle_is_active: jax.Array
 
-    def save(self, path: Path) -> None:
-        np.savez_compressed(
-            path,
-            circle_axy=np.array(self.circle_axy),
-            circle_is_active=np.array(self.circle_is_active),
-            static_circle_axy=np.array(self.static_circle_axy),
-            static_circle_is_active=np.array(self.static_circle_is_active),
-        )
-
     @staticmethod
     def load(path: Path) -> Self:
         npzfile = np.load(path)
@@ -230,9 +221,15 @@ def set_by_index(self, i: int, phys: StateDict) -> StateDict:
         return phys
 
 
-@jax.jit
-def concat_physstates(states: list[SavedPhysicsState]) -> SavedPhysicsState:
-    return jax.tree_map(lambda *args: jnp.concatenate(args, axis=0), *states)
+def save_physstates(phys_states: list[SavedPhysicsState], path: Path) -> None:
+    concatenated = jax.tree_map(lambda *args: np.concatenate(args), *phys_states)
+    np.savez_compressed(
+        path,
+        circle_axy=concatenated.circle_axy,
+        circle_is_active=concatenated.circle_is_active,
+        static_circle_axy=concatenated.static_circle_axy,
+        static_circle_is_active=concatenated.static_circle_is_active,
+    )
 
 
 class LogMode(str, enum.Enum):
@@ -267,7 +264,8 @@ def push_log(self, log: Log) -> None:
         if self.mode not in [LogMode.FULL, LogMode.REWARD_AND_LOG]:
             return
 
-        self._log_list.append(log)
+        # Move log to CPU
+        self._log_list.append(jax.tree_map(np.array, log))
 
         if len(self._log_list) % self.log_interval == 0:
             self._save_log()
@@ -277,7 +275,7 @@ def _save_log(self) -> None:
             return
 
         all_log = jax.tree_map(
-            lambda *args: np.array(jnp.concatenate(args, axis=0)),
+            lambda *args: np.concatenate(args, axis=0),
             *self._log_list,
         )
         log_dict = dataclasses.asdict(all_log)
@@ -296,7 +294,8 @@ def push_physstate(self, phys_state: SavedPhysicsState) -> None:
         if self.mode != LogMode.FULL:
             return
 
-        self._physstate_list.append(phys_state)
+        # Move it to CPU to save memory
+        self._physstate_list.append(jax.tree_map(np.array, phys_state))
 
         if len(self._physstate_list) % self.savestate_interval == 0:
             self._save_physstate()
@@ -305,8 +304,9 @@ def _save_physstate(self) -> None:
         if len(self._physstate_list) == 0:
             return
 
-        concat_physstates(self._physstate_list).save(
-            self.logdir.joinpath(f"state-{self._physstate_index}.npz")
+        save_physstates(
+            self._physstate_list,
+            self.logdir.joinpath(f"state-{self._physstate_index}.npz"),
         )
         self._physstate_index += 1
         self._physstate_list.clear()

From f108bd507916bdf0f91b91ac41a8b38913b6cb3a Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 19 Jan 2024 17:15:29 +0900
Subject: [PATCH 211/337] Show unique_id for reward

---
 src/emevo/analysis/qt_widget.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index e988881c..410a3287 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -243,7 +243,7 @@ def _update_yrange(self, values: Iterable[float | list[float]]) -> None:
         self.axis_y.setRange(yrange_min, np.max(values_arr))
 
     @Slot(dict)
-    def updateValues(self, values: dict[str, float | list[float]]) -> None:
+    def updateValues(self, title: str, values: dict[str, float | list[float]]) -> None:
         new_barsets = deque()
         for name, value in values.items():
             if name not in self.barsets:
@@ -263,6 +263,7 @@ def updateValues(self, values: dict[str, float | list[float]]) -> None:
                 new_barsets.popleft().setColor(old_bs.color())
                 self.series.remove(old_bs)
         self._update_yrange(values.values())
+        self.chart.setTitle(title)
 
 
 class CBarState(enum.Enum):
@@ -273,7 +274,7 @@ class CBarState(enum.Enum):
 
 class CFEnvReplayWidget(QtWidgets.QWidget):
     energyUpdated = Signal(float)
-    rewardUpdated = Signal(dict)
+    rewardUpdated = Signal(str, dict)
 
     def __init__(
         self,
@@ -431,7 +432,10 @@ def updateRewards(self, selected_slot: int) -> None:
         last_log = self._log_cached[-1]
         for slot, uid in zip(last_log["slots"], last_log["unique_id"]):
             if slot == selected_slot:
-                self.rewardUpdated.emit(self._get_rewards(uid))
+                self.rewardUpdated.emit(
+                    f"Reward function of {uid}",
+                    self._get_rewards(uid),
+                )
                 return
 
     @Slot(bool)

From a6b8768b5b85643160d3b28e25738aa224a61a43 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Fri, 19 Jan 2024 18:29:38 +0900
Subject: [PATCH 212/337] Gradual

---
 config/env/20240119-seasons-gradual.toml | 44 ++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 config/env/20240119-seasons-gradual.toml

diff --git a/config/env/20240119-seasons-gradual.toml b/config/env/20240119-seasons-gradual.toml
new file mode 100644
index 00000000..8d12197d
--- /dev/null
+++ b/config/env/20240119-seasons-gradual.toml
@@ -0,0 +1,44 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = [
+   "scheduled",
+   [1024000, 2048000, 10240000],
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["gaussian-mixture",
+       [0.5, 0.5],
+       [[360.0, 270.0], [120.0, 270.0]],
+       [[48.0, 36.0], [48.0, 36.0]],
+   ],
+   ["switching",
+       100,
+       ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+   ]
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
+obstacles = "none"
\ No newline at end of file

From 0234cae598ea9982606e468109cb310b19d2c8f9 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 20 Jan 2024 20:02:56 +0900
Subject: [PATCH 213/337] Tweak on widget and vis

---
 experiments/cf_asexual_evo.py | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index f913d8dd..2744184a 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -53,6 +53,8 @@
 from emevo.spaces import BoxSpace
 from emevo.visualizer import SaveVideoWrapper
 
+PROJECT_ROOT = Path(__file__).parent.parent
+
 
 class RewardKind(str, enum.Enum):
     LINEAR = "linear"
@@ -383,7 +385,6 @@ def replace_net(
 
 
 app = typer.Typer(pretty_exceptions_show_locals=False)
-here = Path(__file__).parent
 
 
 @app.command()
@@ -402,9 +403,9 @@ def evolve(
     n_rollout_steps: int = 1024,
     n_total_steps: int = 1024 * 10000,
     act_reward_coef: float = 0.001,
-    cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
-    bdconfig_path: Path = here.joinpath("../config/bd/20230530-a035-e020.toml"),
-    gopsconfig_path: Path = here.joinpath("../config/gops/20240111-mutation-0401.toml"),
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
+    bdconfig_path: Path = PROJECT_ROOT / "config/bd/20230530-a035-e020.toml",
+    gopsconfig_path: Path = PROJECT_ROOT / "config/gops/20240111-mutation-0401.toml",
     env_override: str = "",
     birth_override: str = "",
     hazard_override: str = "",
@@ -511,17 +512,18 @@ def evolve(
 @app.command()
 def replay(
     physstate_path: Path,
-    n_agents: int = 20,
     backend: str = "pyglet",  # Use "headless" for headless rendering
     videopath: Optional[Path] = None,
     start: int = 0,
     end: Optional[int] = None,
-    cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
     env_override: str = "",
 ) -> None:
     with cfconfig_path.open("r") as f:
         cfconfig = toml.from_toml(CfConfig, f.read())
-    cfconfig.n_initial_agents = n_agents
+    # For speedup
+    cfconfig.n_initial_agents = 1
+    cfconfig.n_initial_foods = 1
     cfconfig.apply_override(env_override)
     phys_state = SavedPhysicsState.load(physstate_path)
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
@@ -545,10 +547,9 @@ def replay(
 @app.command()
 def widget(
     physstate_path: Path,
-    n_agents: int = 20,
     start: int = 0,
     end: Optional[int] = None,
-    cfconfig_path: Path = here.joinpath("../config/env/20231214-square.toml"),
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
     log_offset: int = 0,
     log_path: Optional[Path] = None,
     profile_and_rewards_path: Optional[Path] = None,
@@ -558,7 +559,9 @@ def widget(
 
     with cfconfig_path.open("r") as f:
         cfconfig = toml.from_toml(CfConfig, f.read())
-    cfconfig.n_initial_agents = n_agents
+    # For speedup
+    cfconfig.n_initial_agents = 1
+    cfconfig.n_initial_foods = 1
     cfconfig.apply_override(env_override)
     phys_state = SavedPhysicsState.load(physstate_path)
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))

From e733c99960de0a237ff751073b7523bdc146764b Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Sun, 21 Jan 2024 01:33:41 +0900
Subject: [PATCH 214/337] Seasons + Less foods

---
 config/env/20240121-seasons-lessfoods.toml | 45 ++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 config/env/20240121-seasons-lessfoods.toml

diff --git a/config/env/20240121-seasons-lessfoods.toml b/config/env/20240121-seasons-lessfoods.toml
new file mode 100644
index 00000000..db5a987e
--- /dev/null
+++ b/config/env/20240121-seasons-lessfoods.toml
@@ -0,0 +1,45 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 80
+food_num_fn = [
+   "scheduled",
+   2048000,
+   ["logistic", 20, 0.01, 60],
+   ["logistic", 20, 0.01, 80],
+   ["logistic", 20, 0.01, 60],
+]
+food_loc_fn = [
+   "scheduled",
+   2048000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["switching",
+       100,
+       ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+   ]
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 40.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
+obstacles = "none"
\ No newline at end of file

From fd0d721cffe5bf3c80065e7d2be235189e38c947 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 22 Jan 2024 18:01:54 +0900
Subject: [PATCH 215/337] log_plotting.py

---
 pyproject.toml                     |   1 +
 src/emevo/analysis/log_plotting.py | 126 +++++++++++++++++++++++++++++
 src/emevo/analysis/qt_widget.py    |   1 +
 3 files changed, 128 insertions(+)
 create mode 100644 src/emevo/analysis/log_plotting.py

diff --git a/pyproject.toml b/pyproject.toml
index b2a973de..26103b44 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -35,6 +35,7 @@ dynamic = ["version"]
 analysis = [
     "matplotlib >= 3.0",
     "networkx >= 3.0",
+    "polars >= 0.20",
     "pygraphviz >= 1.0",
     "PySide6 >= 6.5",
 ]
diff --git a/src/emevo/analysis/log_plotting.py b/src/emevo/analysis/log_plotting.py
new file mode 100644
index 00000000..279431f4
--- /dev/null
+++ b/src/emevo/analysis/log_plotting.py
@@ -0,0 +1,126 @@
+from os import PathLike
+from pathlib import Path
+
+import numpy as np
+import polars as pl
+import seaborn as sns
+from matplotlib.axes import Axes
+from matplotlib.collections import LineCollection
+from mpl_toolkits.mplot3d import Axes3D
+from mpl_toolkits.mplot3d.art3d import Line3DCollection
+
+from emevo.analysis import Tree
+from emevo.exp_utils import SavedPhysicsState
+
+
+def load_log(pathlike: PathLike, last_idx: int = 10) -> pl.LazyFrame:
+    if isinstance(pathlike, Path):
+        path = pathlike
+    else:
+        path = Path(pathlike)
+    parquets = []
+    for idx in range(1, last_idx + 1):
+        logpath = path.joinpath(f"log-{idx}.parquet").expanduser()
+        if logpath.exists():
+            parquets.append(pl.scan_parquet(logpath))
+    return pl.concat(parquets)
+
+
+def plot_rewards_3d(
+    ax: Axes3D,
+    reward_df: pl.DataFrame,
+    tree_df: pl.DataFrame,
+    reward_prefix_1: str = "w",
+    reward_prefix_2: str = "alpha",
+    tree: Tree | None = None,
+    reward_axis: str = "food",
+) -> Axes3D:
+    tr = tree_df.join(reward_df, on="unique_id")
+    labels = set(tree_df["label"])
+    palette = sns.color_palette("husl", len(labels))
+    r1, r2 = f"{reward_prefix_1}_{reward_axis}", f"{reward_prefix_2}_{reward_axis}"
+    colors = [palette[label] for label in tree_df["label"]]
+    scatter = ax.scatter(tr[r1], tr[r2], tr["birthtime"], c=colors, s=5, marker="o")
+    ax.set_xlim((-1, 1))
+    ax.set_ylim((-1, 1))
+    ax.set_xlabel(r1)
+    ax.set_ylabel(r2)
+    ax.set_zlabel("Birth Step")
+    if tree != None:
+        x, y, z = scatter._offsets3d  # type: ignore
+        x = x.data
+        y = y.data
+
+        def get_pos(ij: tuple[int, int]) -> tuple | None:
+            i, j = ij[0] - 1, ij[1] - 1
+            if i >= len(x) or j >= len(x):
+                return None
+            return ((x[i], y[i], z[i]), (x[j], y[j], z[j]))
+
+        edge_collection = Line3DCollection(
+            [e for e in map(get_pos, tree.all_edges()) if e is not None],
+            colors="gray",
+            linewidths=0.1,
+            alpha=0.4,
+        )
+        ax.add_collection(edge_collection)
+    return ax
+
+
+def plot_rewards(
+    ax: Axes,
+    reward_df: pl.DataFrame,
+    tree_df: pl.DataFrame,
+    tree: Tree | None = None,
+    reward_axis: str = "food",
+) -> Axes:
+    tr = tree_df.join(reward_df, on="index")
+    labels = set(tree_df["label"])
+    palette = sns.color_palette("husl", len(labels))
+    sns.scatterplot(
+        data=tr,
+        x="birth-step",
+        y=reward_axis,
+        hue="label",
+        palette=palette,
+        ax=ax,
+        legend=False,
+    )
+    if tree != None:
+
+        def get_pos(ij: tuple[int, int]) -> tuple | None:
+            stepi = tr.filter(pl.col("index") == ij[0])
+            stepj = tr.filter(pl.col("index") == ij[1])
+            if len(stepi) != 1 or len(stepj) != 1:
+                return None
+            return (
+                (stepi["birthtime"].item(), stepi[reward_axis].item()),
+                (stepj["birthtime"].item(), stepj[reward_axis].item()),
+            )
+
+        edge_collection = LineCollection(
+            [e for e in map(get_pos, tree.all_edges()) if e is not None],
+            colors="gray",
+            linewidths=0.5,
+            antialiaseds=(1,),
+            alpha=0.6,
+        )
+        ax.add_collection(edge_collection)
+    return ax
+
+
+def plot_lifehistory(
+    ax: Axes,
+    phys_state: SavedPhysicsState,
+    slot: int,
+    start: int,
+    end: int,
+    xlim: float = 480.0,
+    ylim: float = 360.0,
+) -> None:
+    assert start < end
+    axy = np.array(phys_state.circle_axy[start:end, slot])
+    x = axy[1]
+    y = axy[2]
+    ax.plot(x, y)
+    return ax
diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index 410a3287..28e28ada 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -429,6 +429,7 @@ def updateRewards(self, selected_slot: int) -> None:
 
         if len(self._log_cached) == 0:
             return
+
         last_log = self._log_cached[-1]
         for slot, uid in zip(last_log["slots"], last_log["unique_id"]):
             if slot == selected_slot:

From b4c91a111d3d00b8361590eb8d53b40bed5ffe36 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 23 Jan 2024 18:10:14 +0900
Subject: [PATCH 216/337] Fix tree test

---
 tests/test_tree.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_tree.py b/tests/test_tree.py
index 87b080ac..9fbe2e5f 100644
--- a/tests/test_tree.py
+++ b/tests/test_tree.py
@@ -70,5 +70,5 @@ def test_from_table() -> None:
             assert node.birth_time is not None
 
     data_dict = tree.as_datadict(split=10)
-    for key in ["index", "birth-step", "label", "in-label-0", "in-label-1"]:
+    for key in ["unique_id", "label", "in-label-0", "in-label-1"]:
         assert key in data_dict

From a3c396288830d369c8680ad73f69c72d8b88ddcf Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 24 Jan 2024 17:31:39 +0900
Subject: [PATCH 217/337] Fix unique_id detection of widget and add slider

---
 experiments/cf_asexual_evo.py   |  8 ++--
 src/emevo/analysis/qt_widget.py | 79 ++++++++++++++++++++++++---------
 2 files changed, 61 insertions(+), 26 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 2744184a..d83415aa 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -523,7 +523,6 @@ def replay(
         cfconfig = toml.from_toml(CfConfig, f.read())
     # For speedup
     cfconfig.n_initial_agents = 1
-    cfconfig.n_initial_foods = 1
     cfconfig.apply_override(env_override)
     phys_state = SavedPhysicsState.load(physstate_path)
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
@@ -561,20 +560,19 @@ def widget(
         cfconfig = toml.from_toml(CfConfig, f.read())
     # For speedup
     cfconfig.n_initial_agents = 1
-    cfconfig.n_initial_foods = 1
     cfconfig.apply_override(env_override)
     phys_state = SavedPhysicsState.load(physstate_path)
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
     end = phys_state.circle_axy.shape[0] if end is None else end
     if log_path is None:
         log_ds = None
+        step_offset = 0
     else:
         import pyarrow.dataset as ds
 
         log_ds = ds.dataset(log_path)
         first_step = log_ds.scanner(columns=["step"]).head(1)["step"][0].as_py()
-        log_start = first_step + start + log_offset
-        log_offset = log_start
+        step_offset = first_step + log_offset
 
     if profile_and_rewards_path is None:
         profile_and_rewards = None
@@ -592,7 +590,7 @@ def widget(
         start=start,
         end=end,
         log_ds=log_ds,
-        log_offset=log_offset,
+        step_offset=step_offset,
         profile_and_rewards=profile_and_rewards,
     )
 
diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index 28e28ada..68a0f9df 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -52,7 +52,8 @@ def _mgl_qsurface_fmt() -> QSurfaceFormat:
     return fmt
 
 
-N_MAX_SCAN: int = 10000
+N_MAX_SCAN: int = 4096
+N_MAX_CACHED_LOG: int = 200
 
 
 @jax.jit
@@ -62,7 +63,8 @@ def _overlap(p: jax.Array, circle: Circle, state: State) -> jax.Array:
 
 
 class MglWidget(QOpenGLWidget):
-    selectionChanged = Signal(int)
+    selectionChanged = Signal(int, int)
+    stepChanged = Signal(int)
 
     def __init__(
         self,
@@ -72,6 +74,7 @@ def __init__(
         saved_physics: SavedPhysicsState,
         figsize: tuple[float, float],
         start: int = 0,
+        slider_offset: int = 0,
         end: int | None = None,
         get_colors: Callable[[int], NDArray] | None = None,
         parent: QtWidgets.QWidget | None = None,
@@ -103,6 +106,7 @@ def __init__(
         self._initialized = False
         self._overlay_fns = []
         self._showing_energy = False
+        self._slider_offset = slider_offset
 
         # Set timer
         self._timer = timer
@@ -141,6 +145,7 @@ def paintGL(self) -> None:
             self._initialized = True
         if not self._paused and self._index < self._end_index - 1:
             self._index += 1
+            self.stepChanged.emit(self._index)
         stated = self._get_stated(self._index)
         if self._get_colors is None:
             circle_colors = None
@@ -160,7 +165,7 @@ def mousePressEvent(self, evt: QMouseEvent) -> None:  # type: ignore
         )
         (selected,) = jnp.nonzero(overlap)
         if 0 < selected.shape[0]:
-            self.selectionChanged.emit(selected[0].item())
+            self.selectionChanged.emit(selected[0].item(), self._index)
 
     @Slot()
     def pause(self) -> None:
@@ -170,6 +175,10 @@ def pause(self) -> None:
     def play(self) -> None:
         self._paused = False
 
+    @Slot(int)
+    def sliderChanged(self, slider_index: int) -> None:
+        self._index = slider_index - self._slider_offset
+
 
 class BarChart(QtWidgets.QWidget):
     def __init__(
@@ -284,7 +293,7 @@ def __init__(
         saved_physics: SavedPhysicsState,
         start: int = 0,
         end: int | None = None,
-        log_offset: int = 0,
+        step_offset: int = 0,
         log_ds: ds.Dataset | None = None,
         profile_and_rewards: pa.Table | None = None,
     ) -> None:
@@ -299,13 +308,23 @@ def __init__(
             figsize=(xlim * 2, ylim * 2),
             start=start,
             end=end,
+            slider_offset=step_offset,
             get_colors=None if log_ds is None else self._get_colors,
         )
         self._n_max_agents = env.n_max_agents
-        # Log
-        self._log_offset = log_offset
+        # Log / step
         self._log_ds = log_ds
-        self._log_cached = []
+        self._log_cached = {}
+        self._step_offset = step_offset
+        self._start = start
+        self._end = end
+        # Slider
+        self._slider = QtWidgets.QSlider(Qt.Horizontal)  # type: ignore
+        self._slider.setSingleStep(1)
+        self._slider.setMinimum(start + step_offset)
+        self._slider.setMaximum(self._mgl_widget._end_index + step_offset - 1)
+        self._slider.setValue(start + step_offset)
+        self._slider_label = QtWidgets.QLabel(f"Step {start + step_offset}")
         # Pause/Play
         pause_button = QtWidgets.QPushButton("⏸️")
         pause_button.clicked.connect(self._mgl_widget.pause)
@@ -330,19 +349,25 @@ def __init__(
         self._norm = mc.Normalize(vmin=0.0, vmax=1.0)
         if profile_and_rewards is not None:
             self._profile_and_rewards = profile_and_rewards
-            self._reward_widget = BarChart(self._get_rewards(1))
+            self._reward_widget = BarChart(self._get_rewards(1))  # type: ignore
         # Layout buttons
+        left_control = QtWidgets.QVBoxLayout()
         buttons = QtWidgets.QHBoxLayout()
         buttons.addWidget(pause_button)
         buttons.addWidget(play_button)
+        left_control.addLayout(buttons)
+        left_control.addWidget(self._slider_label)
+        left_control.addWidget(self._slider)
         cbar_selector = QtWidgets.QVBoxLayout()
         cbar_selector.addWidget(radiobutton_1)
         cbar_selector.addWidget(radiobutton_2)
         cbar_selector.addWidget(radiobutton_3)
-        buttons.addLayout(cbar_selector)
+        control = QtWidgets.QHBoxLayout()
+        control.addLayout(left_control)
+        control.addLayout(cbar_selector)
         # Total layout
         total_layout = QtWidgets.QVBoxLayout()
-        total_layout.addLayout(buttons)
+        total_layout.addLayout(control)
         total_layout.addWidget(self._cbar_canvas)
         if profile_and_rewards is None:
             total_layout.addWidget(self._mgl_widget)
@@ -355,6 +380,8 @@ def __init__(
         timer.start(30)  # 40fps
         # Signals
         self._mgl_widget.selectionChanged.connect(self.updateRewards)
+        self._mgl_widget.stepChanged.connect(self.updateStep)
+        self._slider.sliderMoved.connect(self._mgl_widget.sliderChanged)
         if profile_and_rewards is not None:
             self.rewardUpdated.connect(self._reward_widget.updateValues)
         # Initial size
@@ -376,10 +403,11 @@ def _get_n_children(self, unique_id: int) -> int:
             return 0
         return len(self._profile_and_rewards.filter(pc.field("parent") == unique_id))
 
-    def _get_colors(self, index: int) -> NDArray:
+    def _get_log(self, step: int) -> dict[str, NDArray]:
         assert self._log_ds is not None
-        step = self._log_offset + index
-        if len(self._log_cached) == 0:
+        log_key = step // N_MAX_SCAN
+        if log_key not in self._log_cached:
+            log_key = step // N_MAX_SCAN
             scanner = self._log_ds.scanner(
                 columns=["age", "energy", "step", "slots", "unique_id"],
                 filter=(
@@ -387,11 +415,17 @@ def _get_colors(self, index: int) -> NDArray:
                 ),
             )
             table = scanner.to_table()
-            self._log_cached = [
+            if len(self._log_cached) > N_MAX_CACHED_LOG:
+                self._log_cached.clear()
+            self._log_cached[log_key] = [
                 table.filter(pc.field("step") == i).to_pydict()
                 for i in reversed(range(step, step + N_MAX_SCAN))
             ]
-        log = self._log_cached.pop()
+        return self._log_cached[log_key][step % N_MAX_SCAN]
+
+    def _get_colors(self, step_index: int) -> NDArray:
+        assert self._log_ds is not None
+        log = self._get_log(self._step_offset + step_index)
         slots = np.array(log["slots"])
         if self._cbar_state is CBarState.AGE:
             title = "Age"
@@ -423,15 +457,18 @@ def _get_colors(self, index: int) -> NDArray:
         return cm(self._norm(value))
 
     @Slot(int)
-    def updateRewards(self, selected_slot: int) -> None:
-        if self._profile_and_rewards is None or selected_slot == -1:
-            return
+    def updateStep(self, step_index: int) -> None:
+        step = self._step_offset + step_index
+        self._slider.setValue(step)
+        self._slider_label.setText(f"Step {step}")
 
-        if len(self._log_cached) == 0:
+    @Slot(int, int)
+    def updateRewards(self, selected_slot: int, step_index: int) -> None:
+        if self._profile_and_rewards is None or selected_slot == -1:
             return
 
-        last_log = self._log_cached[-1]
-        for slot, uid in zip(last_log["slots"], last_log["unique_id"]):
+        log = self._get_log(self._step_offset + step_index)
+        for slot, uid in zip(log["slots"], log["unique_id"]):
             if slot == selected_slot:
                 self.rewardUpdated.emit(
                     f"Reward function of {uid}",

From 67b8d8dcf05545d31c22021cb372b6c504540a41 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 25 Jan 2024 17:08:02 +0900
Subject: [PATCH 218/337] Fix unique_id generation

---
 src/emevo/env.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/emevo/env.py b/src/emevo/env.py
index 78c5318f..91b1c276 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -62,18 +62,20 @@ def init_status(max_n: int, init_energy: float) -> Status:
 class UniqueID:
     """Unique ID for agents. Starts from 1."""
 
-    unique_id: jax.Array
+    unique_id: jax.Array  # (N,)
+    max_uid: jax.Array  # (1,)
 
     def activate(self, flag: jax.Array) -> Self:
         unique_id = jnp.where(
             flag,
-            jnp.cumsum(flag) + jnp.max(self.unique_id),
+            jnp.cumsum(flag) + self.max_uid,
             self.unique_id,
         )
-        return UniqueID(unique_id=unique_id)
+        max_uid = self.max_uid + jnp.sum(flag)
+        return UniqueID(unique_id=unique_id, max_uid=max_uid)
 
     def deactivate(self, flag: jax.Array) -> Self:
-        return UniqueID(unique_id=jnp.where(flag, -1, self.unique_id))
+        return dataclasses.replace(self, unique_id=jnp.where(flag, -1, self.unique_id))
 
     def is_active(self) -> jax.Array:
         return 1 <= self.unique_id
@@ -83,6 +85,7 @@ def init_uniqueid(n: int, max_n: int) -> UniqueID:
     zeros = jnp.zeros(max_n - n, dtype=jnp.int32)
     return UniqueID(
         unique_id=jnp.concatenate((jnp.arange(1, n + 1, dtype=jnp.int32), zeros)),
+        max_uid=jnp.array(max_n),
     )
 
 

From 3b9a373bad10c1375e303e9aaa421765277538ac Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 25 Jan 2024 17:19:58 +0900
Subject: [PATCH 219/337] Fix unique_id initialization

---
 src/emevo/env.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/emevo/env.py b/src/emevo/env.py
index 91b1c276..7de14615 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -85,7 +85,7 @@ def init_uniqueid(n: int, max_n: int) -> UniqueID:
     zeros = jnp.zeros(max_n - n, dtype=jnp.int32)
     return UniqueID(
         unique_id=jnp.concatenate((jnp.arange(1, n + 1, dtype=jnp.int32), zeros)),
-        max_uid=jnp.array(max_n),
+        max_uid=jnp.array(n + 1),
     )
 
 

From fcff55b33c82ee3eff5b3c0f491381f6e3333ea7 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 25 Jan 2024 17:33:01 +0900
Subject: [PATCH 220/337] Use cfconfig also in circle_ppo.py

---
 requirements/smoke.in     |  2 +-
 smoke-tests/circle_ppo.py | 94 +++++++++++----------------------------
 2 files changed, 27 insertions(+), 69 deletions(-)

diff --git a/requirements/smoke.in b/requirements/smoke.in
index 21e619c3..05545803 100644
--- a/requirements/smoke.in
+++ b/requirements/smoke.in
@@ -1,4 +1,4 @@
--e .[video,pyside6]
+-e .[video]
 py-spy  # for profiling
 tqdm
 typer
\ No newline at end of file
diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index 3544441c..17cd3f3c 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -1,5 +1,6 @@
 """Example of using circle foraging environment"""
 
+import dataclasses
 from pathlib import Path
 from typing import Optional
 
@@ -10,10 +11,12 @@
 import numpy as np
 import optax
 import typer
+from serde import toml
 
 from emevo import Env, make
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
+from emevo.exp_utils import CfConfig
 from emevo.rl.ppo_normal import (
     NormalPPONet,
     Rollout,
@@ -25,7 +28,8 @@
 )
 from emevo.visualizer import SaveVideoWrapper
 
-N_MAX_AGENTS: int = 10
+PROJECT_ROOT = Path(__file__).parent.parent
+N_MAX_AGENTS: int = 20
 
 
 def weight_summary(network):
@@ -63,7 +67,7 @@ def step(key: chex.PRNGKey, state: State, obs: Obs) -> tuple[State, Obs, jax.Arr
         state, obs, act = step(key, state, obs)
         del act
         # print(f"Act: {act[0]}")
-        visualizer.render(state.physics) # type: ignore
+        visualizer.render(state.physics)  # type: ignore
         visualizer.show()
 
 
@@ -221,8 +225,6 @@ def train(
     modelpath: Path = Path("trained.eqx"),
     seed: int = 1,
     n_agents: int = 2,
-    n_foods: int = 10,
-    obstacles: str = "none",
     adam_lr: float = 3e-4,
     adam_eps: float = 1e-7,
     gamma: float = 0.999,
@@ -231,40 +233,19 @@ def train(
     minibatch_size: int = 128,
     n_rollout_steps: int = 1024,
     n_total_steps: int = 1024 * 1000,
-    n_sensors: int = 16,
-    sensor_length: float = 100.0,
-    food_loc_fn: str = "gaussian",
-    env_shape: str = "circle",
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
+    env_override: str = "",
     reset_interval: Optional[int] = None,
-    xlim: int = 200,
-    ylim: int = 200,
-    linear_damping: float = 0.8,
-    angular_damping: float = 0.6,
-    max_force: float = 40.0,
-    min_force: float = -20.0,
     debug_vis: bool = False,
 ) -> None:
-    assert n_agents < N_MAX_AGENTS
-    env = make(
-        "CircleForaging-v0",
-        env_shape=env_shape,
-        n_max_agents=N_MAX_AGENTS,
-        n_initial_agents=n_agents,
-        food_num_fn=("constant", n_foods),
-        food_loc_fn=food_loc_fn,
-        agent_loc_fn="gaussian",
-        foodloc_interval=20,
-        obstacles=obstacles,
-        xlim=(0.0, float(xlim)),
-        ylim=(0.0, float(ylim)),
-        env_radius=min(xlim, ylim) * 0.5,
-        linear_damping=linear_damping,
-        angular_damping=angular_damping,
-        max_force=max_force,
-        min_force=min_force,
-        n_agent_sensors=n_sensors,
-        sensor_length=sensor_length,
-    )
+    # Load config
+    with cfconfig_path.open("r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+    # Apply overrides
+    cfconfig.apply_override(env_override)
+    cfconfig.n_initial_agents = n_agents
+    cfconfig.n_max_agents = N_MAX_AGENTS
+    env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
     network = run_training(
         jax.random.PRNGKey(seed),
         n_agents,
@@ -286,43 +267,20 @@ def train(
 def vis(
     modelpath: Path = Path("trained.eqx"),
     n_total_steps: int = 1000,
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
     seed: int = 1,
-    n_agents: int = 2,
-    n_foods: int = 10,
-    food_loc_fn: str = "gaussian",
-    env_shape: str = "circle",
-    obstacles: str = "none",
     videopath: Optional[Path] = None,
-    xlim: int = 200,
-    ylim: int = 200,
-    linear_damping: float = 0.8,
-    angular_damping: float = 0.6,
-    max_force: float = 40.0,
-    min_force: float = -20.0,
-    n_sensors: int = 16,
-    sensor_length: float = 100.0,
+    env_override: str = "",
     headless: bool = False,
 ) -> None:
-    assert n_agents < N_MAX_AGENTS
-    env = make(
-        "CircleForaging-v0",
-        env_shape=env_shape,
-        n_max_agents=N_MAX_AGENTS,
-        n_initial_agents=n_agents,
-        food_num_fn=("constant", n_foods),
-        food_loc_fn=food_loc_fn,
-        foodloc_interval=20,
-        obstacles=obstacles,
-        xlim=(0.0, float(xlim)),
-        ylim=(0.0, float(ylim)),
-        env_radius=min(xlim, ylim) * 0.5,
-        linear_damping=linear_damping,
-        angular_damping=angular_damping,
-        n_agent_sensors=n_sensors,
-        sensor_length=sensor_length,
-        max_force=max_force,
-        min_force=min_force,
-    )
+    # Load config
+    with cfconfig_path.open("r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+    # Apply overrides
+    cfconfig.apply_override(env_override)
+    cfconfig.n_initial_agents = n_agents
+    cfconfig.n_max_agents = N_MAX_AGENTS
+    env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
     obs_space = env.obs_space.flatten()
     input_size = np.prod(obs_space.shape)
     act_size = np.prod(env.act_space.shape)

From 8e313c565162eb1d8d094b10c833781f598b2409 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 26 Jan 2024 01:45:16 +0900
Subject: [PATCH 221/337] Use action_reward and entropy_weight in circle_ppo

---
 smoke-tests/circle_ppo.py | 57 +++++++++++++++++++++++++++------------
 1 file changed, 40 insertions(+), 17 deletions(-)

diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index 17cd3f3c..6c61b982 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -78,7 +78,14 @@ def exec_rollout(
     network: NormalPPONet,
     prng_key: jax.Array,
     n_rollout_steps: int,
+    action_reward_coef: float,
 ) -> tuple[State, Rollout, Obs, jax.Array]:
+    def normalize_action(action: jax.Array) -> jax.Array:
+        scaled = env.act_space.sigmoid_scale(action)
+        max_norm = jnp.sqrt(jnp.sum(env.act_space.high**2, axis=-1, keepdims=True))
+        norm = jnp.sqrt(jnp.sum(scaled**2, axis=-1, keepdims=True))
+        return norm / max_norm
+
     def step_rollout(
         carried: tuple[State, Obs],
         key: jax.Array,
@@ -88,7 +95,8 @@ def step_rollout(
         net_out = vmap_apply(network, obs_t_array)
         actions = net_out.policy().sample(seed=key)
         state_t1, timestep = env.step(state_t, env.act_space.sigmoid_scale(actions))
-        rewards = obs_t.collision[:, 1].astype(jnp.float32).reshape(-1, 1)
+        food_rewards = obs_t.collision[:, 1].astype(jnp.float32).reshape(-1, 1)
+        rewards = food_rewards - action_reward_coef * normalize_action(actions)
         rollout = Rollout(
             observations=obs_t_array,
             actions=actions,
@@ -124,6 +132,8 @@ def training_step(
     minibatch_size: int,
     n_optim_epochs: int,
     reset: jax.Array,
+    action_reward_coef: float,
+    entropy_weight: float,
 ) -> tuple[State, Obs, jax.Array, optax.OptState, NormalPPONet]:
     keys = jax.random.split(prng_key, N_MAX_AGENTS + 1)
     env_state, rollout, obs, next_value = exec_rollout(
@@ -133,6 +143,7 @@ def training_step(
         network,
         keys[0],
         n_rollout_steps,
+        action_reward_coef,
     )
     rollout = rollout.replace(terminations=rollout.terminations.at[-1].set(reset))
     batch = vmap_batch(rollout, next_value, gamma, gae_lambda)
@@ -145,7 +156,7 @@ def training_step(
         minibatch_size,
         n_optim_epochs,
         0.2,
-        0.0,
+        entropy_weight,
     )
     return env_state, obs, rollout.rewards, opt_state, pponet
 
@@ -161,9 +172,11 @@ def run_training(
     minibatch_size: int,
     n_rollout_steps: int,
     n_total_steps: int,
+    action_reward_coef: float,
+    entropy_weight: float,
     reset_interval: int | None = None,
     debug_vis: bool = False,
-) -> NormalPPONet:
+) -> tuple[NormalPPONet, jax.Array]:
     key, net_key, reset_key = jax.random.split(key, 3)
     obs_space = env.obs_space.flatten()
     input_size = np.prod(obs_space.shape)
@@ -202,6 +215,8 @@ def run_training(
             minibatch_size,
             n_optim_epochs,
             jnp.array(reset),
+            action_reward_coef,
+            entropy_weight,
         )
         ri = jnp.sum(jnp.squeeze(rewards_i, axis=-1), axis=0)
         rewards = rewards + ri
@@ -214,7 +229,7 @@ def run_training(
             obs = timestep.obs
         # weight_summary(pponet)
     print(f"Sum of rewards {[x.item() for x in rewards[: n_agents]]}")
-    return pponet
+    return pponet, rewards
 
 
 app = typer.Typer(pretty_exceptions_show_locals=False)
@@ -233,9 +248,12 @@ def train(
     minibatch_size: int = 128,
     n_rollout_steps: int = 1024,
     n_total_steps: int = 1024 * 1000,
+    action_reward_coef: float = 1e-3,
+    entropy_weight: float = 1e-4,
     cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
     env_override: str = "",
     reset_interval: Optional[int] = None,
+    savelog_path: Optional[Path] = None,
     debug_vis: bool = False,
 ) -> None:
     # Load config
@@ -246,26 +264,31 @@ def train(
     cfconfig.n_initial_agents = n_agents
     cfconfig.n_max_agents = N_MAX_AGENTS
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
-    network = run_training(
-        jax.random.PRNGKey(seed),
-        n_agents,
-        env,
-        optax.adam(adam_lr, eps=adam_eps),
-        gamma,
-        gae_lambda,
-        n_optim_epochs,
-        minibatch_size,
-        n_rollout_steps,
-        n_total_steps,
-        reset_interval,
-        debug_vis,
+    network, rewards = run_training(
+        key=jax.random.PRNGKey(seed),
+        n_agents=n_agents,
+        env=env,
+        adam=optax.adam(adam_lr, eps=adam_eps),
+        gamma=gamma,
+        gae_lambda=gae_lambda,
+        n_optim_epochs=n_optim_epochs,
+        minibatch_size=minibatch_size,
+        n_rollout_steps=n_rollout_steps,
+        n_total_steps=n_total_steps,
+        action_reward_coef=action_reward_coef,
+        entropy_weight=entropy_weight,
+        reset_interval=reset_interval,
+        debug_vis=debug_vis,
     )
     eqx.tree_serialise_leaves(modelpath, network)
+    if savelog_path is not None:
+        np.savez(savelog_path, np.array(rewards))
 
 
 @app.command()
 def vis(
     modelpath: Path = Path("trained.eqx"),
+    n_agents: int = 2,
     n_total_steps: int = 1000,
     cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
     seed: int = 1,

From 0c0b56890bd89168e487656d9fbc88abe9f5d963 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 26 Jan 2024 16:45:47 +0900
Subject: [PATCH 222/337] Mild

---
 config/bd/20240126-mild.toml | 14 +++++++
 notebooks/bd_rate.ipynb      | 72 ++++++++++++++++++------------------
 smoke-tests/circle_ppo.py    | 25 +++++++++++--
 3 files changed, 71 insertions(+), 40 deletions(-)
 create mode 100644 config/bd/20240126-mild.toml

diff --git a/config/bd/20240126-mild.toml b/config/bd/20240126-mild.toml
new file mode 100644
index 00000000..13b83aa9
--- /dev/null
+++ b/config/bd/20240126-mild.toml
@@ -0,0 +1,14 @@
+birth_fn = "emevo.birth_and_death.EnergyLogisticBirth"
+hazard_fn = "emevo.birth_and_death.ELGompertzHazard"
+
+[hazard_params]
+alpha = 0.1
+alpha_age = 1e-6
+beta = 1e-5
+scale = 0.01
+e0 = 0.0
+
+[birth_params]
+alpha = 0.01
+scale = 4e-5
+e0 = 10.0
\ No newline at end of file
diff --git a/notebooks/bd_rate.ipynb b/notebooks/bd_rate.ipynb
index 386dc981..4ebb4fac 100644
--- a/notebooks/bd_rate.ipynb
+++ b/notebooks/bd_rate.ipynb
@@ -2,18 +2,10 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 12,
    "id": "0dadbf8d-d3eb-42b8-a9c1-265e61f6edd8",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import dataclasses\n",
     "from typing import Any, Literal\n",
@@ -40,7 +32,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 13,
    "id": "c4b6ebde-ea34-4a3e-92b3-964ac39c8452",
    "metadata": {},
    "outputs": [],
@@ -74,7 +66,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 14,
    "id": "8d94990f-99ac-4dc0-a5c9-1b19806b8885",
    "metadata": {},
    "outputs": [],
@@ -102,7 +94,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 15,
    "id": "8c0388cd-0f78-4094-8129-a448bd2446e0",
    "metadata": {},
    "outputs": [],
@@ -163,7 +155,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 16,
    "id": "f6e5195d-4ce1-4b04-a74b-a7abe805810b",
    "metadata": {},
    "outputs": [],
@@ -237,7 +229,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 17,
    "id": "b6836a43-b466-4d86-9094-21a3560624cd",
    "metadata": {},
    "outputs": [],
@@ -289,16 +281,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 20,
    "id": "caf049a1-8651-46bf-82e8-84c249545b13",
-   "metadata": {
-    "scrolled": true
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "280272ef3dc745a796e3b4a7f8481575",
+       "model_id": "e46c965f352b455f937f67e3bc154557",
        "version_major": 2,
        "version_minor": 0
       },
@@ -306,25 +296,25 @@
        "VBox(children=(Text(value='figure.png', description='Filename:'), Button(description='Save File', style=Button…"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "5ff7bf17c4fd42d7983fb0cab52c53a3",
+       "model_id": "d657b9b7d02b4e7596b6360d5914eb35",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAASwCAYAAAAnoTQJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3gU1frHv7N9Nz0hIQkQOqFKlWIDAQmK3iuiXrnqBdtFRexybVes4FWxYcEKWK4otp8Vr1QpofcWikCQJARC+mbrnN8fy052zsxmNhBMdvJ+nodHZ+bMzJnZ2Z1v3vc93yMwxhiIqGPu3Lm49957UVZW1thdIQiCIAiCw9DYHSCaFpMmTULHjh1ht9uRmpqKv/71r9izZ0+d+3z99dcYNWoUUlJSIAgCtmzZotouNzcXw4cPR0xMDOLj43HRRRehpqbmjPv85ptvol27drDZbBg0aBDWrVsnbTt58iSmTJmC7Oxs2O12ZGVl4e6770Z5efkZn5cgCIIgwkECi5DRv39/zJkzB7t378Yvv/wCxhhGjRoFv98fdp/q6mpccMEF+M9//hO2TW5uLkaPHo1Ro0Zh3bp1WL9+Pe666y4YDGf2CH7++ee4//77MW3aNGzatAm9e/dGTk4OiouLAQAFBQUoKCjASy+9hB07dmDu3LlYuHAhbrnlljM6L0EQBEHUCSPOGgsWLGA9e/ZkNpuNJScnsxEjRrCqqipp+wcffMC6d+/OLBYLS09PZ5MnT5a2zZw5k/Xs2ZM5HA7WunVrdscdd7DKykpp+5w5c1hCQoLsfN9++y3r27cvs1qtrH379uzJJ59kXq/3jK5h69atDADbv3+/ZtuDBw8yAGzz5s2KbYMGDWKPP/54nfvn5+eza665hiUkJLCkpCT2l7/8hR08eLDOfQYOHCi7b36/n2VmZrIZM2aE3eeLL75gFovljO8NQRAEQYSDIlhnicLCQowfPx4333wzdu/ejWXLluGqq64CO1Xy9vbbb2Py5Mn45z//ie3bt+O7775Dp06dpP0NBgNef/117Ny5E/PmzcOSJUswderUsOdbsWIF/vGPf+Cee+7Brl278M4772Du3Ll47rnnpDYTJ07EsGHDIr6G6upqzJkzB+3bt0ebNm3qfxNOUVxcjLVr1yItLQ3nnXceWrZsiaFDh2LlypVSG6/Xi5ycHMTFxWHFihVYtWoVYmNjMXr0aHg8HtXjejwebNy4ESNHjpTWGQwGjBw5Erm5uWH7U15ejvj4eJhMptO+JoIgCIKok8ZWeHpl48aNDAA7dOiQ6vbMzEz22GOPRXy8BQsWsJSUFGmZj2CNGDGCTZ8+XbbPxx9/zDIyMqTlhx9+mN14442a53rzzTdZTEwMA8Cys7Mjil4xFj6ClZubywCw5ORk9uGHH7JNmzaxe++9l1ksFrZ3716pr9nZ2UwURWk/t9vN7HY7++WXX1TPd/ToUQaArV69Wrb+oYceYgMHDlTd5/jx4ywrK4s9+uijEV0TQRAEQZwOFME6S/Tu3RsjRoxAr169cM011+C9995DaWkpgEBEp6CgACNGjAi7/6JFizBixAi0atUKcXFxuPHGG1FSUgKn06nafuvWrXj66acRGxsr/bvttttQWFgo7TNjxgx89NFHmn2//vrrsXnzZixfvhxdunTBtddeC5fLdRp3IYAoigACBfQ33XQT+vbti1deeQXZ2dn48MMPpf7v378fcXFxUv+Tk5Phcrlw4MABrFixQnZtn376ab37UVFRgTFjxqB79+548sknT/t6CIIgCEILypGcJYxGI3799VesXr0a//vf/zBr1iw89thjWLt2LVq0aFHnvocOHcLll1+OO+64A8899xySk5OxcuVK3HLLLfB4PHA4HIp9qqqq8NRTT+Gqq65SbLPZbPXqe0JCAhISEtC5c2cMHjwYSUlJ+OabbzB+/Ph6HSdIRkYGAKB79+6y9d26dUN+fr7U//79+6sKp9TUVFgsFtnoxJYtW8JqtcJoNOLYsWOy9seOHUN6erpsXWVlJUaPHo24uDh88803MJvNp3UtBEEQBBEJFME6iwiCgPPPPx9PPfUUNm/eDIvFgm+++QZxcXFo164dFi9erLrfxo0bIYoiZs6cicGDB6NLly4oKCio81z9+vVDXl4eOnXqpPh3JiP1GGNgjMHtdp/2Mdq1a4fMzEzk5eXJ1u/duxdt27aV+r9v3z6kpaUp+p+QkAC73S5bFxcXB4vFgv79+8vuoyiKWLx4MYYMGSKtq6iowKhRo2CxWPDdd9/VW3ASBEEQRH2hCNZZYu3atVi8eDFGjRqFtLQ0rF27FsePH0e3bt0AAE8++SRuv/12pKWl4dJLL0VlZSVWrVqFKVOmoFOnTvB6vZg1axauuOIKrFq1CrNnz67zfE888QQuv/xyZGVl4eqrr4bBYMDWrVuxY8cOPPvsswCARx55BEePHg2bJvz999/x+eefY9SoUUhNTcUff/yB559/Hna7HZdddpnUrmvXrpgxYwbGjh0LIOA1lZ+fL4nAoJBKT09Heno6BEHAQw89hGnTpqF3797o06cP5s2bhz179uDLL78EEEhLvvjii/jrX/+Kp59+Gq1bt8bhw4fx9ddfY+rUqWjdurVqn++//35MmDABAwYMwMCBA/Hqq6+iuroaN910E4BaceV0OvHJJ5+goqICFRUVAAKRMaPRqP1hEgRBEER9aewiML2ya9culpOTw1JTU5nVamVdunRhs2bNkrWZPXs2y87OZmazmWVkZLApU6ZI215++WWWkZHB7HY7y8nJYR999BEDwEpLSxlj6jYNCxcuZOeddx6z2+0sPj6eDRw4kL377rvS9gkTJrChQ4eG7fPRo0fZpZdeytLS0pjZbGatW7dmf//739mePXtk7QCwOXPmSMtz5sxhABT/pk2bJttvxowZrHXr1szhcLAhQ4awFStWyLYXFhayf/zjH6xFixbMarWyDh06sNtuu42Vl5eH7TNjjM2aNYtlZWUxi8XCBg4cyNasWSNtW7p0qWrfAGhaQBAEQRDE6SIwRlPlEARBEARBNCRUg0UQBEEQBNHAkMAiCIIgCIJoYEhgEQRBEARBNDAksAiCIAiCIBoYElgEQRAEQRANDAmsRiY/Px9jxoyBw+FAWloaHnroIfh8vnodY9myZRAEQfGvqKiozv22bduGCy+8EDabDW3atMELL7ygaLNgwQJ07doVNpsNvXr1wk8//VSvvp0Ob775Jtq1awebzYZBgwZh3bp1su0ulwuTJ09GSkoKYmNjMW7cOIWbO0EQBEE0JiSwGhG/348xY8bA4/Fg9erVmDdvHubOnYsnnnjitI6Xl5eHwsJC6V9aWlrYtkEDzrZt22Ljxo148cUX8eSTT+Ldd9+V2qxevRrjx4/HLbfcgs2bN+PKK6/ElVdeiR07dpxW/wBg7ty5GDZsWNjtn3/+Oe6//35MmzYNmzZtQu/evZGTk4Pi4mKpzX333Yfvv/8eCxYswPLly1FQUKA6RRBBEARBNBqNbcSlZ/x+P5s+fTpr164ds9ls7JxzzmELFiyQtv/000/MYDCwoqIiad3bb7/N4uPjmdvtjvg8QTPNoAlpJLz11lssKSlJdp5//etfLDs7W1q+9tpr2ZgxY2T7DRo0iE2aNEladrlc7IEHHmCZmZnM4XCwgQMHsqVLl4Y975w5c+o0Ox04cCCbPHmytOz3+1lmZiabMWMGY4yxsrIyZjabZfdx9+7dDADLzc3VvG6CIAiC+DOgCNZZZMaMGfjoo48we/Zs7Ny5E/fddx9uuOEGLF++HACQm5uLXr16oWXLltI+OTk5qKiowM6dOwEEJn4WBAHLli3TPF+fPn2QkZGBSy65BKtWraqzbW5uLi666CJYLBbZufPy8lBaWiq1GTlypGy/nJwc5ObmSst33XUXcnNzMX/+fGzbtg3XXHMNRo8ejX379mn2l8fj8WDjxo2ycxoMBowcOVI658aNG+H1emVtunbtiqysLFm/CIIgCKIxobkIzxJutxvTp0/HokWLpImHO3TogJUrV+Kdd97B0KFDUVRUJBNXAKTlYP2U2WxGdnY2HA5H2HNlZGRg9uzZGDBgANxuN95//30MGzYMa9euRb9+/VT3KSoqQvv27cOeOykpKWz/gn3Lz8/HnDlzkJ+fj8zMTADAgw8+iIULF2LOnDmYPn16RPcqyIkTJ+D3+1XPuWfPHqlvFosFiYmJYftFEARBEI0NCayzxP79++F0OnHJJZfI1ns8HvTt2zfi47Rq1UoSF+HIzs5Gdna2tHzeeefhwIEDeOWVV/Dxxx/Xr+P1YPv27fD7/ejSpYtsvdvtRkpKCoCACOvevbu0zefzwev1IjY2Vlr36KOP4tFHHz1r/SQIgiCIPxsSWGeJqqoqAMCPP/6IVq1aybZZrVYAQHp6umKEXHA0XHp6+hmdf+DAgVi5cmXY7enp6YqRd/y5w7UJbq+qqoLRaMTGjRthNBpl7YICKjMzE1u2bJHWf/311/jqq6/w6aefSuuSk5MBAC1atIDRaKzznOnp6fB4PCgrK5NFsULbEARBEERjQzVYZ4nu3bvDarUiPz8fnTp1kv1r06YNAGDIkCHYvn27bITcr7/+ivj4eFnU53TYsmULMjIywm4fMmQIfvvtN3i9Xtm5s7OzkZSUJLVZvHixbL9ff/1VSnn27dsXfr8fxcXFimsMih2TySRbn5aWBrvdLlsXFFgWiwX9+/eXnVMURSxevFg6Z//+/WE2m2Vt8vLykJ+fL7UhCIIgiEansavs9cxjjz3GUlJS2Ny5c9n+/fvZxo0b2euvv87mzp3LGGPM5/Oxnj17slGjRrEtW7awhQsXstTUVPbII49Ix/jjjz9YdnY2W7t2bdjzvPLKK+zbb79l+/btY9u3b2f33HMPMxgMbNGiRVKbWbNmseHDh0vLZWVlrGXLluzGG29kO3bsYPPnz2cOh4O98847UptVq1Yxk8nEXnrpJbZ79242bdo0Zjab2fbt26U2119/PWvXrh376quv2O+//87Wrl3Lpk+fzn744QfVvmqNIpw/fz6zWq1s7ty5bNeuXeyf//wnS0xMlI20vP3221lWVhZbsmQJ27BhAxsyZAgbMmRI2GMSBEEQxJ8NCayziCiK7NVXX2XZ2dnMbDaz1NRUlpOTw5YvXy61OXToELv00kuZ3W5nLVq0YA888ADzer3S9oMHDzIAdVof/Oc//2EdO3ZkNpuNJScns2HDhrElS5bI2kybNo21bdtWtm7r1q3sggsuYFarlbVq1Yo9//zzimN/8cUXrEuXLsxisbAePXqwH3/8Ubbd4/GwJ554grVr146ZzWaWkZHBxo4dy7Zt26baVy2BxVhADGZlZTGLxcIGDhzI1qxZI9teU1PD7rzzTpaUlMQcDgcbO3YsKywsrPOYBEEQBPFnIjDGWGNH0QiCIAiCIPQE1WARBEEQBEE0MCSwCIIgCIIgGhgSWARBEARBEA0MCSyCIAiCIIgGhgRWIxKcZzDUiFOLuXPnKqaJIQiCIAiiaUECi2jSvPvuuxg2bBji4+MhCALKysoi2u/NN99Eu3btYLPZMGjQIIVjvsvlwuTJk5GSkoLY2FiMGzdO4SB/OjDG8MQTTyAjIwN2ux0jR45UTHzdrl07CIIg+/f888+f8bkJgiCIpgMJLKJJ43Q6MXr06HrNVfj555/j/vvvx7Rp07Bp0yb07t0bOTk5Msf8++67D99//z0WLFiA5cuXo6CgAFddddUZ9/eFF17A66+/jtmzZ2Pt2rWIiYlBTk4OXC6XrN3TTz+NwsJC6d+UKVPO+NwEQRBEE6KRfbh0zc8//8zOP/98lpCQwJKTk9mYMWPY/v37pe1BE9HNmzczxhhbunQpA8B++OEH1qtXL2a1WtmgQYNkzulz5sxhCQkJbOHChaxr164sJiaG5eTksIKCAqnNunXr2MiRI1lKSgqLj49nF110Edu4cWPE/Z45cybr2bMnczgcrHXr1uyOO+5glZWVsjbvvvsua926NbPb7ezKK69kM2fOZAkJCbI23377Levbty+zWq2sffv27Mknn5SZqNaH4L0pLS3VbDtw4EA2efJkadnv97PMzEw2Y8YMxljAxd5sNrMFCxZIbXbv3s0AsNzcXGnd9u3b2ejRo1lMTAxLS0tjN9xwAzt+/HjY84qiyNLT09mLL74orSsrK2NWq5V99tln0rq2bduyV155JZLLJgiCIKIUimCdRaqrq3H//fdjw4YNWLx4MQwGA8aOHQtRFOvc76GHHsLMmTOxfv16pKam4oorrpDNGeh0OvHSSy/h448/xm+//Yb8/Hw8+OCD0vbKykpMmDABK1euxJo1a9C5c2dcdtllqKysjKjfBoMBr7/+Onbu3Il58+ZhyZIlmDp1qrR91apVuP3223HPPfdgy5YtuOSSS/Dcc8/JjrFixQr84x//wD333INdu3bhnXfewdy5c2XtJk6ciGHDhkXUp0jxeDzYuHEjRo4cKbuekSNHIjc3FwCwceNGeL1eWZuuXbsiKytLalNWVobhw4ejb9++2LBhAxYuXIhjx47h2muvDXvugwcPoqioSHbchIQEDBo0SDpukOeffx4pKSno27cvXnzxRfh8vga5foIgCKKJ0NgKrzlx/PhxBkCKSIWLYM2fP1/ap6SkhNntdvb5558zxgIRLACySNibb77JWrZsGfa8fr+fxcXFse+///60+r1gwQKWkpIiLf/tb39jY8aMkbW5/vrrZRGsESNGsOnTp8vafPzxxywjI0Nafvjhh9mNN94YUR8ijWAdPXqUAWCrV6+WrX/ooYfYwIEDGWOMffrpp8xisSj2Pffcc9nUqVMZY4w988wzbNSoUbLtR44cYQBYXl6e6rlXrVrFAMiiiYwxds0117Brr71WWp45cyZbunQp27p1K3v77bdZYmIiu+++++q8LoIgCCK6MDWetNM/+/btwxNPPIG1a9fixIkTUuQqPz8fPXv2DLvfkCFDpP9PTk5GdnY2du/eLa1zOBzo2LGjtJyRkSGrLzp27Bgef/xxLFu2DMXFxfD7/XA6ncjPz4+o34sWLcKMGTOwZ88eVFRUwOfzweVywel0wuFwIC8vD2PHjpXtM3DgQPzwww/S8tatW7Fq1SpZxMrv98uOM2PGjIj60xhs3boVS5cuRWxsrGLbgQMHsH79ekyaNEla9/PPP8NoNEZ07Pvvv1/6/3POOQcWiwWTJk3CjBkzYLVaz7zzBEEQRKNDAusscsUVV6Bt27Z47733kJmZCVEU0bNnT3g8njM6rtlsli0LggAWMqXkhAkTUFJSgtdeew1t27aF1WrFkCFDIjrvoUOHcPnll+OOO+7Ac889h+TkZKxcuRK33HILPB4PHA5HRH2sqqrCU089pVo4brPZIjrG6dCiRQsYjUbFiMBjx44hPT0dAJCeng6Px4OysjKZ5UVom6qqKlxxxRX4z3/+ozhHRkYGRFHEoEGDpHWtWrVCYWGhdJyMjAzZcfv06RO2z4MGDYLP58OhQ4eQnZ1d72smCIIgmh4ksM4SJSUlyMvLw3vvvYcLL7wQALBy5cqI9l2zZg2ysrIAAKWlpdi7dy+6desW8blXrVqFt956C5dddhkA4MiRIzhx4kRE+27cuBGiKGLmzJkwGAIlel988YWsTXZ2NtavXy9bxy/369cPeXl56NSpU8T9bggsFgv69++PxYsX48orrwQAiKKIxYsX46677gIA9O/fH2azGYsXL8a4ceMAAHl5ecjPz5eih/369cNXX32Fdu3awWRS/5rExcXJltu3b4/09HQsXrxYElQVFRVYu3Yt7rjjjrB93rJlCwwGA9LS0s7k0gmCIIgmBAmss0RSUhJSUlLw7rvvIiMjA/n5+Xj44Ycj2vfpp59GSkoKWrZsicceewwtWrSQxEIkdO7cGR9//DEGDBiAiooKPPTQQ7Db7RHt26lTJ3i9XsyaNQtXXHEFVq1ahdmzZ8vaTJkyBRdddBFefvllXHHFFViyZAl+/vlnCIIgtXniiSdw+eWXIysrC1dffTUMBgO2bt2KHTt24NlnnwUAPPLIIzh69Cg++uijsP0pKipCUVER9u/fDwDYvn074uLikJWVheTkZADAiBEjMHbsWElA3X///ZgwYQIGDBiAgQMH4tVXX0V1dTVuuukmAIHC81tuuQX3338/kpOTER8fjylTpmDIkCEYPHgwAGDy5Ml47733MH78eEydOhXJycnYv38/5s+fj/fff181HSgIAu699148++yz6Ny5M9q3b49///vfyMzMlD6/3NxcrF27FhdffDHi4uKQm5uL++67DzfccAOSkpIi+owIgiCIKKCxi8D0zK+//sq6devGrFYrO+ecc9iyZcsYAPbNN98wxsIXuX///fesR48ezGKxsIEDB7KtW7dKxwzaNITyzTffsNCPctOmTWzAgAHMZrOxzp07swULFtTLGuDll19mGRkZzG63s5ycHPbRRx8pCszfffdd1qpVK8mm4dlnn2Xp6emy4yxcuJCdd955zG63s/j4eDZw4ED27rvvStsnTJjAhg4dWmdfpk2bxgAo/s2ZM0dq07ZtWzZt2jTZfrNmzWJZWVnSPVyzZo1se01NDbvzzjtZUlISczgcbOzYsaywsFDWZu/evWzs2LEsMTGR2e121rVrV3bvvfcyURTD9lcURfbvf/+btWzZklmtVjZixAhZUfzGjRvZoEGDWEJCArPZbKxbt25s+vTpzOVy1XkfCIIgiOhCYCykeIdoVJYtW4aLL74YpaWlUTcdzm233YY9e/ZgxYoVjd0VgiAIgmh0KEVInBYvvfQSLrnkEsTExODnn3/GvHnz8NZbbzV2twiCIAiiSUBGo82MTz/9FLGxsar/evToEfFx1q1bh0suuQS9evXC7Nmz8frrr+PWW289iz0nCIIgiOiBUoTNjMrKyrCTGpvNZrRt2/ZP7hFBEARB6A8SWARBEARBEA0MpQgJgiAIgiAaGBJYjcihQ4cgCAK2bNkS8T5z586NuhGGBEEQBNHcIIFFqHLy5ElMmTIF2dnZsNvtyMrKwt13343y8vKw+3i9XvzrX/9Cr169EBMTg8zMTPzjH/9AQUGBanu3240+ffrUW2SGw+VyYfLkyUhJSUFsbCzGjRunqDe7++670b9/f1it1jqnryEIgiCIM4EEFqFKQUEBCgoK8NJLL2HHjh2YO3cuFi5ciFtuuSXsPk6nE5s2bcK///1vbNq0CV9//TXy8vLwl7/8RbX91KlTkZmZ2WB9vu+++/D9999jwYIFWL58OQoKClTnQrz55pvxt7/9rcHOSxAEQRAKGtPlVO/8/PPP7Pzzz2cJCQksOTmZjRkzhu3fv1/aHs7J/YcffmC9evViVquVDRo0iG3fvl3aJ+jkvnDhQta1a1cWExPDcnJyWEFBgdRm3bp1bOTIkSwlJYXFx8eziy66iG3cuPGMr+eLL75gFouFeb3eiPdZt24dA8AOHz4sW//TTz+xrl27sp07d8ruQZAVK1awCy64gNlsNta6dWs2ZcoUVlVVFfY8ZWVlzGw2swULFkjrdu/ezQCw3NxcRftp06ax3r17R3wdBEEQBFEfKIJ1Fqmursb999+PDRs2YPHixTAYDBg7dixEUaxzv4ceeggzZ87E+vXrkZqaiiuuuAJer1fa7nQ68dJLL+Hjjz/Gb7/9hvz8fDz44IPS9srKSkyYMAErV67EmjVr0LlzZ1x22WWorKyU2kycOBHDhg2r1/WUl5cjPj4+7OTH4fYRBEFWN3bs2DHcdttt+Pjjj+FwOBT7HDhwAKNHj8a4ceOwbds2fP7551i5cqU016AaGzduhNfrxciRI6V1Xbt2RVZWFnJzcyPuL0EQBEE0BOTkfhYZN26cbPnDDz9Eamoqdu3ahZ49e4bdb9q0abjkkksAAPPmzUPr1q3xzTff4NprrwUQqHWaPXs2OnbsCAC466678PTTT0v7Dx8+XHa8d999F4mJiVi+fDkuv/xyAEBGRoam0AvlxIkTeOaZZ/DPf/4z4n1cLhf+9a9/Yfz48YiPjwcAMMYwceJE3H777RgwYAAOHTqk2G/GjBm4/vrrce+99wIITF79+uuvY+jQoXj77bdhs9kU+xQVFcFisSgGALRs2RJFRUUR95kgCIIgGgKKYJ1F9u3bh/Hjx6NDhw6Ij49Hu3btAAD5+fl17jdkyBDp/5OTk5GdnY3du3dL6xwOhySugIBYKi4ulpaDEaLOnTsjISEB8fHxqKqqkp13xowZ+OijjyK6joqKCowZMwbdu3fHk08+GdE+Xq8X1157LRhjePvtt6X1s2bNQmVlJR555JGw+27duhVz586Vuczn5ORAFEUcPHgQ06dPl23Tup8EQRAE8WdDEayzyBVXXIG2bdvivffeQ2ZmJkRRRM+ePeHxeM7ouGazWbYsCAJYiF/shAkTUFJSgtdeew1t27aF1WrFkCFDTuu8lZWVGD16NOLi4vDNN98ozq1GUFwdPnwYS5YskaJXALBkyRLk5ubCarXK9hkwYACuv/56zJs3D1VVVZg0aRLuvvtuxbGzsrJw++23S9E8AMjMzER6ejo8Hg/KysoU6cj09PR6XzdBEARBnAkksM4SJSUlyMvLw3vvvYcLL7wQALBy5cqI9l2zZg2ysrIAAKWlpdi7dy+6desW8blXrVqFt956C5dddhkA4MiRIzhx4kQ9ryAQucrJyYHVasV3332nmprjCYqrffv2YenSpUhJSZFtf/311/Hss89KywUFBcjJycHnn3+OQYMGAQD69euHXbt2oVOnTqrnSE5ORnJysmxd//79YTabsXjxYik1m5eXh/z8fFlEkCAIgiD+DEhgnSWSkpKQkpKCd999FxkZGcjPz8fDDz8c0b5PP/00UlJS0LJlSzz22GNo0aIFrrzyyojP3blzZ3z88ccYMGAAKioq8NBDD8Fut8vaPPLIIzh69GjYNGFFRQVGjRoFp9OJTz75BBUVFaioqAAApKamwmg0AggUks+YMQNjx46F1+vF1VdfjU2bNuGHH36A3++X6p+Sk5NhsVgk4RgkNjYWANCxY0e0bt0aAPCvf/0LgwcPxl133YVbb70VMTEx2LVrF3799Ve88cYbqv1NSEjALbfcgvvvvx/JycmIj4/HlClTMGTIEAwePFhqt3//flRVVaGoqAg1NTWS/1b37t1hsVgivscEQRAEURcksM4SBoMB8+fPx913342ePXsiOzsbr7/+ekQj955//nncc8892LdvH/r06YPvv/++Xi//Dz74AP/85z/Rr18/tGnTBtOnT5eNMgSAwsLCOmuXNm3ahLVr1wKAIpJ08OBBqZ4sLy9PMh89evQovvvuOwBQmHguXbo04lGL55xzDpYvX47HHnsMF154IRhj6Nixo6Z31SuvvAKDwYBx48bB7XYjJycHb731lqzNrbfeiuXLl0vLffv2VVwTQRAEQZwpNNlzE2LZsmW4+OKLUVpaStPhEARBEEQUQ6MICYIgCIIgGhgSWARBEARBEA0MpQgJgiAIgiAaGIpgEQRBEARBNDAksM4iw4YNk6Z7IQiCIAii+UACq4kzd+7cszqi8O6770b//v1htVoV1grhcLlcmDx5MlJSUhAbG4tx48bh2LFjsjb5+fkYM2YMHA4H0tLS8NBDD8Hn851xf0+ePInrr78e8fHxSExMxC233IKqqirVtvv370dcXByNyCQIgiD+dEhgEbj55ps1PaZCue+++/D9999jwYIFWL58OQoKCnDVVVdJ2/1+P8aMGQOPx4PVq1dj3rx5mDt3Lp544okz7uv111+PnTt34tdff8UPP/yA3377TXUCaq/Xi/Hjx0su+gRBEATxp8KIs8bQoUPZ5MmT2eTJk1l8fDxLSUlhjz/+OBNFUWrjcrnYAw88wDIzM5nD4WADBw5kS5cuZYwxtnTpUgZA9m/atGmMMcY++ugj1r9/fxYbG8tatmzJxo8fz44dO3bafZ02bRrr3bu3ZruysjJmNpvZggULpHW7d+9mAFhubi5jjLGffvqJGQwGVlRUJLV5++23WXx8PHO73dK6b7/9lvXt25dZrVbWvn179uSTTzKv1xv23Lt27WIA2Pr166V1P//8MxMEgR09elTWdurUqeyGG25gc+bMYQkJCZrXRRAEQRANCUWwzjLz5s2DyWTCunXr8Nprr+Hll1/G+++/L22/6667kJubi/nz52Pbtm245pprMHr0aOzbtw/nnXceXn31VcTHx6OwsBCFhYWSI7vX68UzzzyDrVu34ttvv8WhQ4cwceJE2bnbtWuHJ598skGvZ+PGjfB6vRg5cqS0rmvXrsjKykJubi4AIDc3F7169ULLli2lNjk5OaioqMDOnTsBACtWrMA//vEP3HPPPdi1axfeeecdzJ07F88991zYc+fm5iIxMREDBgyQ1o0cORIGg0FynQcCE0ovWLAAb775ZoNdN0EQBEHUB5oq5yzTpk0bvPLKKxAEAdnZ2di+fTteeeUV3HbbbcjPz8ecOXOQn5+PzMxMAMCDDz6IhQsXYs6cOZg+fToSEhIgCALS09Nlx7355pul/+/QoQNef/11nHvuuaiqqpLN79eiRYsGvZ6ioiJYLBZFXVPLli2leQeLiopk4iq4PbgNAJ566ik8/PDDmDBhgnQNzzzzDKZOnYpp06aFPXdaWppsnclkQnJysnTckpISTJw4EZ988gni4+PP7GIJgiAI4jQhgXWWGTx4MARBkJaHDBmCmTNnwu/3Y/v27fD7/ejSpYtsH7fbjZSUlDqPu3HjRjz55JPYunUrSktLIYoigEBxeffu3QEAixcvbuCraTi2bt2KVatWySJWfr8fLpcLTqcT999/Pz755BNpW7hCdp7bbrsNf//733HRRRc1eJ8JgiAIIlJIYDUiVVVVMBqN2LhxI4xGo2xbMAqlRnV1NXJycpCTk4NPP/0UqampyM/PR05ODjwez1ntc3p6OjweD8rKymRRrGPHjklRtvT0dKxbt062X3CUYbBNVVUVnnrqKVlxfBCbzYann35aMUF1eno6iouLZet8Ph9OnjwpHXfJkiX47rvv8NJLLwEAGGMQRREmkwnvvvuuLPJHEARBEGcLElhnmdDaIABYs2YNOnfuDKPRiL59+8Lv96O4uDjsaDeLxQK/3y9bt2fPHpSUlOD5559HmzZtAAAbNmw4OxfA0b9/f5jNZixevBjjxo0DAOTl5SE/Px9DhgwBEIjSPffccyguLpZSer/++ivi4+Ol6Fq/fv2Ql5eHTp06qZ4nLS1NkQ4cMmQIysrKsHHjRvTv3x9AQFCJoohBgwYBCNRphd6v//u//8N//vMfrF69Gq1atWrAO0EQBEEQddDYVfZ6ZujQoSw2Npbdd999bM+ePey///0vi4mJYbNnz5baXH/99axdu3bsq6++Yr///jtbu3Ytmz59Ovvhhx8YY4ytWrWKAWCLFi1ix48fZ9XV1ay4uJhZLBb20EMPsQMHDrD/+7//Y126dGEA2ObNm6VjDx8+nM2aNavOPu7bt49t3ryZTZo0iXXp0oVt3ryZbd68WRrt98cff7Ds7Gy2du1aaZ/bb7+dZWVlsSVLlrANGzawIUOGsCFDhkjbfT4f69mzJxs1ahTbsmULW7hwIUtNTWWPPPKI1GbhwoXMZDKxJ598ku3YsYPt2rWLffbZZ+yxxx6rs7+jR49mffv2ZWvXrmUrV65knTt3ZuPHjw/bnkYREgRBEI0BCayzyNChQ9mdd97Jbr/9dhYfH8+SkpLYo48+KrNp8Hg87IknnmDt2rVjZrOZZWRksLFjx7Jt27ZJbW6//XaWkpIis2n473//y9q1a8esVisbMmQI++677xQCq23btlL7uvoIzgoCADt48CBjjLGDBw8yAJJ1BGOM1dTUsDvvvJMlJSUxh8PBxo4dywoLC2XHPXToELv00kuZ3W5nLVq0YA888IDCgmHhwoXsvPPOY3a7ncXHx7OBAweyd999t87+lpSUsPHjx7PY2FgWHx/PbrrpJlZZWRm2PQksgiAIojGgyZ4JgiAIgiAaGPLBIgiCIAiCaGBIYBEEQRAEQTQwJLAIgiAIgiAaGBJYBEEQBEEQDQwJLIIgCIIgiAaGBBZBEARBEEQDQwKLIAiCIAiigSGBRRAEQRAE0cCQwCIIgiAIgmhgSGARBEEQBEE0MCSwCIIgCIIgGhgSWARBEARBEA0MCSyCIAiCIIgGhgQWQRAEQRBEA0MCiyAIgiAIooEhgUUQBEEQBNHAkMAiCIIgCIJoYEhgEQRBEARBNDAksAiCIAiCIBoYElgEQRAEQRANDAksgiAIgiCIBoYEFkEQBEEQRANDAosgCIIgCKKBIYFFEARBEATRwJDAIgiCIAiCaGBIYBEEQRAEQTQwJLAIgiAIgiAaGBJYBEEQBEEQDQwJLIIgCIIgiAaGBBZBEARBEEQDQwKLIAiCIAiigSGBRRAEQRAE0cCQwCIIgiAIgmhgSGARBEEQBEE0MCSwCIIgCIIgGhgSWARBEARBEA0MCSyCIAiCIIgGhgQWQRAEQRBEA0MCiyAIgiAIooEhgUUQBEEQBNHAkMAiCIIgCIJoYEhgEQRBEARBNDAksAiCIAiCIBoYElgEQRAEQRANDAksgiAIgiCIBoYEFkEQzYqJEyeiXbt2mu3atWuHyy+//Ox36E9i2LBhGDZsmGY7n8+HqVOnok2bNjAYDLjyyivPet9Oh7lz50IQBBw6dKixu0IQqpDAIhqd4A9luH9r1qyR2gqCgLvuuiui437//fe44oor0LJlS1gsFiQnJ+Oiiy7CzJkzUVFRcbYup0kxffp0fPvtt6e178SJExEbGxt2e30+CyJ6+PDDD/Hiiy/i6quvxrx583Dfffc1an/O5BkmiMbE1NgdIIggTz/9NNq3b69Y36lTp3odRxRF3HLLLZg7dy569eqFO++8E23atEFlZSVyc3Px+OOP46effsLixYsbqutNlunTp+Pqq69uslEIoumxZMkStGrVCq+88kpjdwVA+Gf4xhtvxHXXXQer1do4HSMIDUhgEU2GSy+9FAMGDDjj47zwwguYO3cu7rvvPsycOROCIEjb7rnnHhQWFuKjjz464/M0VRhjcLlcsNvtjd2VRsHlcsFiscBgaF4B+urqasTExJzxcYqLi5GYmHjmHTrLGI1GGI3Gxu4GQYSlef0CEbrH6XTiP//5D3r06IEXX3xRJq6CZGRk4F//+pdsnc/nwzPPPIOOHTvCarWiXbt2ePTRR+F2u2XtgnU5y5Ytw4ABA2C329GrVy8sW7YMAPD111+jV69esNls6N+/PzZv3izbP5h2+/3335GTk4OYmBhkZmbi6aefBmNM1lYURbz66qvo0aMHbDYbWrZsiUmTJqG0tFS1T7/88ovUp3feeQeCIKC6uhrz5s2T0q0TJ07EoUOH6kzJni4ejwdPPPEE+vfvj4SEBMTExODCCy/E0qVLZe2GDRsW9txz584FAJw8eRIPPvggevXqhdjYWMTHx+PSSy/F1q1bZcdatmwZBEHA/Pnz8fjjj6NVq1ZwOBxSCvjbb79Fz549YbPZ0LNnT3zzzTf1vq6VK1di4MCBsNls6NChg0KcR9rXdu3ahb3u4PNz+PBh3HnnncjOzobdbkdKSgquueYaRZ1RMK2+fPly3HnnnUhLS0Pr1q2l7e+++y46duwIu92OgQMHYsWKFZrXGXwuli5dip07d8r6FrzPwX7y+wQ/N6D2GT969CiuvPJKxMbGIjU1FQ8++CD8fr9sf1EU8dprr0nfmdTUVIwePRobNmwAgLDPcOg94O/NW2+9hR49esBqtSIzMxOTJ09GWVmZrM2wYcPQs2dP7Nq1CxdffDEcDgdatWqFF154QfM+EUSkUASLaDKUl5fjxIkTsnWCICAlJSXiY6xcuRJlZWV48MEH6/XX7a233op58+bh6quvxgMPPIC1a9dixowZ2L17t+KlvH//fvz973/HpEmTcMMNN+Cll17CFVdcgdmzZ+PRRx/FnXfeCQCYMWMGrr32WuTl5cmiKX6/H6NHj8bgwYPxwgsvYOHChZg2bRp8Ph+efvppqd2kSZMwd+5c3HTTTbj77rtx8OBBvPHGG9i8eTNWrVoFs9kstc3Ly8P48eMxadIk3HbbbcjOzsbHH3+MW2+9FQMHDsQ///lPAEDHjh2RmpqKjz/+WHZNXq8X9913HywWi+Le8J9JOCoqKvD+++9j/PjxuO2221BZWYkPPvgAOTk5WLduHfr06QMAeOyxx3DrrbfK9v3kk0/wyy+/IC0tDQDw+++/49tvv8U111yD9u3b49ixY3jnnXcwdOhQ7Nq1C5mZmbL9n3nmGVgsFjz44INwu92wWCz43//+h3HjxqF79+6YMWMGSkpKcNNNN8mEiBb79+/H1VdfjVtuuQUTJkzAhx9+iIkTJ6J///7o0aNHvfr66quvoqqqSnb8V155BVu2bJGe8fXr12P16tW47rrr0Lp1axw6dAhvv/02hg0bhl27dsHhcMj2v/POO5GamoonnngC1dXVAIAPPvgAkyZNwnnnnYd7770Xv//+O/7yl78gOTkZbdq0CXutwefiueeeQ1VVFWbMmAEA6NatG3bv3h3xPQMCz3hOTg4GDRqEl156CYsWLcLMmTPRsWNH3HHHHVK7YCr/0ksvxa233gqfz4cVK1ZgzZo1GDBgQNhnOBxPPvkknnrqKYwcORJ33HEH8vLy8Pbbb2P9+vWK70xpaSlGjx6Nq666Ctdeey2+/PJL/Otf/0KvXr1w6aWX1ut6CUIVRhCNzJw5cxgA1X9Wq1XWFgCbPHly2GO99tprDAD79ttvZet9Ph87fvy47J8oiowxxrZs2cIAsFtvvVW2z4MPPsgAsCVLlkjr2rZtywCw1atXS+t++eUXBoDZ7XZ2+PBhaf0777zDALClS5dK6yZMmMAAsClTpkjrRFFkY8aMYRaLhR0/fpwxxtiKFSsYAPbpp5/K+rRw4ULF+mCfFi5cqLgfMTExbMKECWHvV5A777yTGY1G2bUG+1rXv9DPwufzMbfbLTtuaWkpa9myJbv55pvDnnvVqlXMbDbL2rhcLub3+2XtDh48yKxWK3v66aeldUuXLmUAWIcOHZjT6ZS179OnD8vIyGBlZWXSuv/9738MAGvbtq3mPQne199++01aV1xczKxWK3vggQfq3VeeL774ggGQteGvgTHGcnNzGQD20UcfSeuC35kLLriA+Xw+ab3H42FpaWmsT58+ss/i3XffZQDY0KFDNa976NChrEePHrJ1wfsc+iwHrxMAmzNnjrQu+Nzw1963b1/Wv39/aXnJkiUMALv77rsVfQh+NxkL/wwH78HBgwcZY4HPxmKxsFGjRsk+jzfeeIMBYB9++KHsGvl76na7WXp6Ohs3bpzyphDEaUApQqLJ8Oabb+LXX3+V/fv555/rdYxgaogf/bZ9+3akpqbK/pWUlAAAfvrpJwDA/fffL9vngQceAAD8+OOPsvXdu3fHkCFDpOVBgwYBAIYPH46srCzF+t9//13Rz9DRd8HReB6PB4sWLQIALFiwAAkJCbjkkktw4sQJ6V///v0RGxurSLu1b98eOTk5dd6bcHz00Ud466238MILL+Diiy+WbbPZbIrPJPiPx2g0ShEwURRx8uRJ+Hw+DBgwAJs2bVI9d1FREa6++mr06dMHb731lrTearVKUT+/34+SkhLExsYiOztb9VgTJkyQ1ZwVFhZiy5YtmDBhAhISEqT1l1xyCbp37x7xvenevTsuvPBCaTk1NRXZ2dmyz7S+fQWAXbt24eabb8Zf//pXPP7449L60Gvwer0oKSlBp06dkJiYqHqs2267TRap3bBhA4qLi3H77bfLopETJ06U3Yc/g9tvv122fOGFF8ru21dffQVBEDBt2jTFvqeTql60aBE8Hg/uvfdeWcT4tttuQ3x8vOJ7HBsbixtuuEFatlgsGDhwoOr3lSBOB0oREk2GgQMHnnGRe1xcHAAoUjGdOnWSRMFHH30kS5EdPnwYBoNBMVoxPT0diYmJOHz4sGx9qIgCIL24+PRLcD1fM2UwGNChQwfZui5dugCAVE+yb98+lJeXSykznuLiYtmy2ujLSNiyZQtuv/12jB8/XiEwgYBoGjlyZMTHmzdvHmbOnIk9e/bA6/XW2T+fz4drr70Wfr8fX3/9tWw0WLA256233sLBgwdltTtqKWP++MHPrHPnzoq2dQkfHv6zBoCkpCTZZ1rfvlZUVOCqq65Cq1at8NFHH8nERE1NDWbMmIE5c+bg6NGjsrq88vJyxbEivW6z2ax45s4mwXqqUPj7duDAAWRmZiI5OblBzhm89uzsbNl6i8WCDh06KL7HrVu3Vgi5pKQkbNu2rUH6QxAksAhd0bVrVwDAjh078Ne//lVaHxsbKwmFlStXqu4b6V/N4Wq7wq1nXPF6JIiiiLS0NHz66aeq2/mX1+mMGCwtLcW4cePQpUsXvP/++/Xen+eTTz7BxIkTceWVV+Khhx5CWloajEYjZsyYgQMHDijaP/TQQ8jNzcWiRYsUdVHTp0/Hv//9b9x888145plnkJycDIPBgHvvvReiKCqOdbZGTEbymda3rxMnTkRBQQHWrVuH+Ph42bYpU6Zgzpw5uPfeezFkyBAkJCRAEARcd911f+p184T7bvBF60GiYXRfQ35fCUINEliErrjwwguRkJCA+fPn45FHHoloqH7btm0hiiL27duHbt26SeuPHTuGsrIytG3btkH7KIoifv/9dylqBQB79+4FAMlhvGPHjli0aBHOP//8M3qJhnsxiqKI66+/HmVlZVi0aJGiePp0+PLLL9GhQwd8/fXXsvOqpYDmz5+PV199Fa+++iqGDh2qeqyLL74YH3zwgWx9WVkZWrRoodmX4Ge2b98+xba8vDzN/etDffr6/PPP49tvv8XXX38t/THAH2vChAmYOXOmtM7lcilGwYUj9LqHDx8urfd6vTh48CB69+4d6WXJSEpKAgBFP/ioUH3o2LEjfvnlF5w8ebLOKFakf/gErz0vL08WrfN4PDh48GC9IrEE0RBQDRahKxwOB6ZOnYodO3bg4YcfVv1rlF932WWXAQiM8grl5ZdfBgCMGTOmwfv5xhtvyPrzxhtvwGw2Y8SIEQAgpc6eeeYZxb4+ny/iF25MTIxq26eeegq//PILPvvss9NOL/IEIwKh93ft2rXIzc2VtduxYwduvfVW3HDDDbjnnnvCHov/nBYsWICjR49G1JeMjAz06dMH8+bNk6XWfv31V+zatSuiY0RKpH1dtGgRHn/8cTz22GNhjV/VjjVr1qywkSKeAQMGIDU1FbNnz4bH45HWz507N+JnRo22bdvCaDTit99+k60PrZurL+PGjQNjDE899ZRiW+g9CPcM84wcORIWiwWvv/66bP8PPvgA5eXlZ+V7TBB1QREsosnw888/Y8+ePYr15513nuwv0g0bNuDZZ59VtBs2bBguuOACPPzww9i9ezdefPFFaah+69atUVpaik2bNmHBggVIS0uDzWYDAPTu3RsTJkzAu+++i7KyMgwdOhTr1q3DvHnzcOWVVyoKv88Um82GhQsXYsKECRg0aBB+/vln/Pjjj3j00Uel1N/QoUMxadIkzJgxA1u2bMGoUaNgNpuxb98+LFiwAK+99hquvvpqzXP1798fixYtwssvv4zMzEy0b98eDocDzzzzDC666CIUFxfjk08+ke0TWvhbHy6//HJ8/fXXGDt2LMaMGYODBw9i9uzZ6N69u6wm7qabbgIAXHTRRYpzBz/ryy+/HE8//TRuuukmnHfeedi+fTs+/fTTetURzZgxA2PGjMEFF1yAm2++GSdPnsSsWbPQo0cPRY3emRBpX8ePH4/U1FR07txZcd2XXHIJWrZsicsvvxwff/wxEhIS0L17dymFGqlVidlsxrPPPotJkyZh+PDh+Nvf/oaDBw9izpw5Z1SDlZCQgGuuuQazZs2CIAjo2LEjfvjhB0UtYH24+OKLceONN+L111/Hvn37MHr0aIiiiBUrVuDiiy+WBoKoPcPBASShpKam4pFHHsFTTz2F0aNH4y9/+Qvy8vLw1ltv4dxzzz3t55ogTpvGGLpIEKHUZdMAbgh4Xe2eeeYZ2XG/+eYbdtlll7HU1FRmMplYYmIiu+CCC9iLL74oG7rPGGNer5c99dRTrH379sxsNrM2bdqwRx55hLlcLlm7tm3bsjFjxiiuASr2EcEh7C+++KK0bsKECSwmJoYdOHCAjRo1ijkcDtayZUs2bdo0xVB/xgLD6/v378/sdjuLi4tjvXr1YlOnTmUFBQWafWKMsT179rCLLrqI2e12BoBNmDBBGnIf7h/f13Dw1yyKIps+fTpr27Yts1qtrG/fvuyHH35gEyZMkNkiBO0P6vqsXS4Xe+CBB1hGRgaz2+3s/PPPZ7m5uWzo0KEyq4HgtSxYsEC1j1999RXr1q0bs1qtrHv37uzrr79W9Ccc4e4r34dI+1rXPQ/aH5SWlrKbbrqJtWjRgsXGxrKcnBy2Z88e1rZtW5lVQfA7s379etW+v/XWW6x9+/bMarWyAQMGsN9++03Rn3Co2TQwxtjx48fZuHHjmMPhYElJSWzSpElsx44dqjYNas/NtGnTZM8XYwFrjxdffJF17dqVWSwWlpqayi699FK2ceNGqY3aMxx6D4I2DUHeeOMN1rVrV2Y2m1nLli3ZHXfcwUpLSyO6xkifDYKIBIExqugjiD+LiRMn4ssvv2zQCApBEATR9KAaLIIgCIIgiAaGBBZBEARBEEQDQwKLIAiCIAiigaEaLIIgCIIgiAaGIlgEQRAEQRANDAksgiAIgiCIBoYEFkEQBEEQRANDAosgCIIgCKKBIYFFEARBEATRwJDAIgiCIAiCaGBIYBEEQRAEQTQwJLAIgiAIgiAaGBJYBEEQBEEQDQwJLIIgCIIgiAaGBBZBEARBEEQDQwKLIAiCIAiigSGBRRAEQRAE0cCQwCIIgiAIgmhgSGARBEEQBEE0MCSwCIIgCIIgGhgSWARBEARBEA0MCSyCIAiCIIgGhgQWQRAEQRBEA0MCiyAIgiAIooEhgUUQBEEQBNHAkMAiCIIgCIJoYEhgEQRBEARBNDAksAiCIAiCIBoYElgEQRAEQRANDAksgiAIgiCIBoYEFkEQBEEQRANDAosgCIIgCKKBIYFFEARBEATRwJDAIgiCIAiCaGBIYBEEQRAEQTQwJLAIgiAIgiAaGBJYBEEQBEEQDQwJLIIgCIIgiAaGBBZBEHUiiiIYY43dDYIgiKjC1NgdIAii6SKKIqqrq+Hz+WA2m2EymWAymWA0GiEIQmN3jyAIoslCAosgCAWMMfj9fni9Xvj9fvj9fgCAx+OB3+9HaWkpMjMzYTabYTQaSXARBEFwkMAiCEIGYwzl5eU4evQoOnToIK03mQI/Fx6PB3v27EFqaio8Hg8EQYDBYIDRaCTBRRAEcQoSWARBSASjVk6nE3/88Qc6deqkaGMwBEo3TSaTVJsliiK8Xq9McIWmE0lwEQTR3CCBRRAEGGPw+Xzw+XwAAiKqrsL24LagaDIajbL1oijC4/HA7XaT4CIIollCAosgmjnB6JMoigAgCSJeRAUJLjPGwm5TE1xutxsejwcASHARBKF7SGARRDOFMSYTVwaDQRI5giCEjWDVRwiFCi6j0QjGmPTP7XbLIlzB+i2TySTrC0EQRDRCAosgmiGMMWmEIACFoOEFlmAoh2j8Egb/nXVGsLQQBEEmukIFl8vlktoEBVcwwkWCiyCIaIMEFkE0M4JRK7/fX6dwkQSWYQOM1scAxAH+O5Xbz4BIBVcwskWCiyCIaIEEFkE0E4LeVj6fT5ES5AlEsPzwYhZgmQ1BEAFmkbadLcIJLlEUSXARBBFVkMAiiGaAVkqQRzAcR8/+b8Mv7A1Z6w5sC0kRnm0iEVwGg0FRNE+CiyCIxoYEFkHonKC3lVbUSmqPpTA4HkGSo4Lb4pYtNcb8hOEEV9BtPlzRfOh+BEEQfwYksAhCp4R6WzHGNMUVgwdevAJRmAupFbMAgufUgjyC1RQICqeg+Wmo4PL5fNJ2PqVIgosgiLMNCSyC0CGiKMLn80WcEhRxCF48AIbj3BYrgFMCS3CDgf2pKcL6Ek5w+Xw+eL3esIIr2J4gCKKhIIFFEDoi1NsqaKOgnRL8Dl48BQhOgGVyWy3cslta1xQFFg8JLoIgGgsSWAShE/hCdi1xxeCEFy9BFD4LWWvmWvECywNBsDZIfxuDugRXcXExSktL0alTJ0lokeAiCOJ0IYFFEDogUm8rqT3y4MX9YIqfAF5g8dtdEIR4ANERwdIiVHD5/X5UV1dDEARp4mqgdlofElwEQdQHElgEEcXUx9sqiA+fwocXAcENgXVHqEwSYJItg5kB2eFqRxLqQWDxBMVWaIQrKF49Ho8kyELTicFRigRBEKGQwCKIKKW+3lYM5adSgl+GrOV/AjSWBTfA6p6rMFpRu55gfVZom6Dg8nq9UhsSXARB8JDAIogoRBRFeDyeiKNWIjbBgwchoCW3hU91GTWWm55Vw59JXYIrGOEyGAwwGo2SD1fQFoIgiOYFCSyCiCKCKcHgKEHtqJUIP96DD28Agg9gGVwLXmBxy0xdYAX70twhwUUQRDhIYBFElFBfbyuG4lPGod+GrOXb88sagiskgkUCS0mo4AreHzXBFZpSJMFFEPqEBBZBNHFOz9tqBbx4BALac1u0BJT8uAwG+ZqQGiw90pDXFTqlDyAXXB6PRzatDwkugtAfJLAIogkTOt0NEIm3lRc+vAo/5gACA1iHep5RK8LlkvVNT5zt66lLcLndboUtBAkugohuSGARRBMlGLUSRREANL2XRPwBH16DKPxQR6v6iQjGBE5iBUQApQjPnFDBFTpxNWNMIbhCJ66OZFADQRCNDwksgmhinI63lR8/w4tpENCVP5rW2erZu0AEi17wDU9odJIXXC5X7X0PCq5Q01P6PAii6UECiyCaEEFvqy1btqBjx46IiYnRSAm64MMM+IUvgis0EDWWNQ4g6HsUYVMSKiS4CCK6IYFFEE2E0OluSkpK0LZt2zpflCL2w4c3IQoLZWv5VnJ4UVTfZUoRNhaRCi61iatJcBHEnw8JLIJoZNS8rQwGQ50Cxocv4MMMCOjFH41b9tdzuW5BxuCCABJYTYFwgksURUlwBZ8lElwE8edDAosgGpFw090IgiAVt8vaowpePAFR+PnUCr6NloDy1a+94vhu6JVoF4zhBJff78fJkydRWFiIbt26keAiiD8JElgE0UgEo1ZqhexqESwR2+DDexCFRbK13FG55XoKKm6Z8ccXalNR0S5I9E5QcBkMBoiiCKfTCUEQ4Pf74ff7JR+uYEoxdB5FElwEceaQwCKIPxne20otghAawWJg8OND+PAaBPTmjlZfgeXVWObb88enGqxoJDT1HLT7CEa4fD4fvF6vJKz4Gi4SXARxepDAIog/Ed7bKtzLKxjBYjgJLx6GKKwIbFCk7OonoJimoOKWBX67vid71ut1BWcACCU0whVsE4ng0vJjIwgiAAksgvgTCJ3uJhJvK0EQYDRvhBff14orAPWtsWKnIk618IKL366VUtSvk7ueURNYPJEKrtB0IgkugggPCSyCOMuEK2QP2x5+ZGZ9g5jkH8HQj9vKCx4twcQv80Xq8u3agotShNFIJAKLJ5zgCk5cDdRO60OCiyCUkMAiiLNIqLdVJKO1GArhwYNo2XrTqRVaNVb1E1Da2+WCTVCkDPXr5K5nwSiK4hl/ZlqCKzTCFTqPIgkuorlCAosgzgKnN93NIvjxBZiwSbZWDh9x4muqeAHlOrPtQvjj61mQ6I3TiWBpoSa4gn9QeL1eqU2o4AqOUiSI5gAJLIJoYOqfEvTAh//AL/wXAhvAbdUaFcgLJG5Z8ALMAAinImGCH2Cm2uJ1wQswARCCYkkrwqXvFKFeX/5nQ2DxBAviQ88ZFFzBCJfBYFAdpUgQeoQEFkE0IHV5W6m2x0H4cD+YsOfUGl608DVWvADiI04+gBkDQkrCCqAmZNkGoIpbPrVd8MgEl6CIYOk3Rahn/gyBxVMfwWU2m6WUIj1bhF4ggUUQDUCot1XQc0hbXH0LH74PEVeBtXLqmwIEAoLKGbIcIqAAABauvYXbbq09rsBFsHQ+2bNeaQyBxROp4OJruBq73wRxupDAIogzRBRF+Hy+eqQEq+HFUxCF7yGwc7mtWjYLfMSKAczCCSEb5AKLF1RWjWULaiNV6ilEvaYI9UpTEFg8oYIr+CyJogiPxyO5zJPgIqIZElgEcZqE/gUefIFpR612nUoJHj61pr6jBNUiVjaunVqEKhSzxrKaAAueV79Go3oWjE1RYIUSOociQIKL0AcksAjiNOAL2SMRVz58BD+WhIgrQKvmShmxEsNErCpClusrqLTa10a0aBRhdNLUBRaPmuAK/nO73TIfrmD9lslkoomriSYFCSyCqCf197YqhRePQRSWqqQEGyNixX/t+eU6jif4weDTbYpQry/nYF1gtBL6B4zRaJQJLpcr8B0pLCxEixYtEBcXJzM91etnSjR9SGARRIScnrfVengxFRCKwrTQqLkS3FwNFKCMWMkFlACTLC5W32VtweWml1aUEW0RLC3UBNeRI0cQGxsLs9kstQlGuEhwEY0BCSyCiID6e1uJ8ONt+LGaE1d81EfL1woA7Ki7aJ2PUBnruSz/GVAKLv74Lt1GsPSK3gQWjyAIEEURZrMZZrNZNcIVbuJqPd8XonEhgUUQGgQLbSONWjEUw4MHwYT1EFh//mjccqQpwfACS4BZIwLFCyo+VcQv8/vzAivQZxJY0UO0pwgjIfj9BMKnFEVRJMFF/GmQwCKIMARTgsFRgpH8+PqwDD48Cgilp9bwLzV5zZUyJehSSQnyo/rOVEDVM8LFjEDoZQv6TBHqWTDqPYIFyAUWT12Cy+12w+VywWAwKEYpkuAizgQSWAShwulNdzMTItaFiCs1+KJ23jgU0DIGVUastAQW3+/6LvM/E5QijDYaYrLnpkxQMEUapeNH/Qb39/v98Pv9ki1EMMIVOo+inu8j0bCQwCKIEE7H20pEPry4H0zYCYH14o/ILatPPSPHDrnA0hoF2NCCSivC5QZg1KXA0uvLU+8RLFEMpN5PNw2qNnF1cHYGr9crbVebR1HP95U4M0hgEcQpQqe7ASLztvLjR3gxDRCqT63hxcjpCCx5SlAZsaqvoNJCa3/+fG4IQowuBZZeIYFVP05XcOm9zo2oHySwCAK1heyrV69Gv379YLfb62zPUAMfnoUfuSHiClAKLHlRu7LmygcwU+C/EvwowfpGrJS9rXuZR0NgCW4IQqzGMaIPPQvG5iKwztY1kuAiTgcSWESzJjQlKIoiqqqqpB/rcIjIgxcPgAkHANaO21p3UXv4lGBlyLKW7UJDC6q6twswcC0CdWN6FiR6ozkIrFABdLbRElwApIL50DouElzNCxJYRLNFrZDdYDDUKbB8+C98eCFgAApAOcKPR2PqGwC8wNIuYudflLzQ4fuvtVxfoeSmIvcoozkIrMYUL+EEl9frlU3rw8+jSIJL35DAIpol4aa7CSewGCrgxb8hCv+TrVeacmrVXNVAiZZxaH0jVlqCio+qaQku/vz6tGnQMySw/lzUBFfwNycY4RIEQSa4gqMUCf1AAotoVmh5WxmNRoXAErEZHjwICAUAswW8qiT4r5CGwFKtueKjYPWNWPGCqb7LGoJM4M+nX5sGvb7gSGA1LsH6rCChgsvj8UiCLCi4QkcpEtELCSyi2RCJt1VoBCsw3c378GFWiCByQF5HpVXUrp0S1C5i56lvhIqfjkdLcGkIJ4Gc3KON5iCwoun6IhFcBoMBRqMRZrNZSilG0zUSJLCIZkIwaqU13U1QYDEchxcvQhS+51rw0aYzL2pXphnrW2PFCyh+mU9T8staAow/n0uXP/R6FozNQWCFCpZoI1LBxddw6fkz1QMksAhdw3tbaTmyGwwGGExr4MZ/oIxOAQGX9VD4Y0UyebPW1DdaAqu+gkqrff0iWoyK3KOO5iCwmnKKsL6ECq7g90wURdTU1GDLli3o3bs3LBYLTCYTGGMoLi5Ghw4dGrPLhAr6eSIJgiPobRWpcSiDD63afQlH0r8AoQTq4ogvQOcJM7egDL6oXesvb60UoFxQ8V5bWsvagkx9gmoSWNGD3id71pvACiXUY0sQBFRXV8NsNoMxBo/Hg127dqFHjx6N3U1CBYpgEbqD97aKZMJWEUfhwyy0bPVzyFqnop0Ai8aoQV68AIGUYO2xtJ3ZtYrY6xZUyj7wdWC84KpnylDQb5G7XmkOESw9X18Qv98vpQuD1+tyuRAbqz/jXz2gT8lPNFtCvWfURgmq4ccv8GAsGH6XbxB8ANOKNkVS1M6nFbVSglo1Vrwgqp+g0l7WElz6TRHq9SXdHARWNNdgRYrf71fUXjmdThJYTRSKYBG6IZy3VTgYXPDhefiFz0+t4IUFEBg1GCpA+B/xSIratQQWDy+wtCJWvKDil/k+1d2ej2gxxTXq08ldb9cTSnMQWHpNEYYS/G0Lpbq6GjExMY3UI6IuSGARUU/Q28rn89UjJbgfPrwBUfglZG249F5ZyDL/I346RqJaKUGtiJWGgBLcgUMGb4HgA5gREPzq2zUiWgJ8iqly9BrB0ivNQWDp+fqCBCNYoZDAarroX/ITuiaYEgxnHKqGDwvgwbVgOCk/lmp6jx/xxx+bNxL1BMSMDC2BVXcRu7Jf3LLgUSmk56Nm/HWEbndzGk+jRksgJ/doQ+8CpDlFsNQEFqUImyYUwSKilki9rYIwVMGLaRCFn4IrOCKxVOAJl1asa25BLRsGrYiVWpTMxq23QX49NsiL9i212wUGMGvIefjzqfeHIljRQ3OIYDWnGqxQqqqqSGA1UfQv+QndEVrIHnlKcDs8+GetuDq1Vo7aqMG6p8JhDVJzxacENWqsBBFgvF0Ef04+asYv19FeERFT9kevKUK9ipDmILCaawTL6XRSirCJov8nktAVwUL2SI1DGRh8mAMProcy8sPPuVcDpki18eIokqJ2rbkF6665UhaxRyLi+HPyy7wg45fr2l/ZHz2/rPVIcxBYer6+IBTBii4oRUhEBaHeVsGXhXZK8CS8eBiisOLUCl5U8JEjgIk2CMZQIcaLI36f0ylqr3uUoLJo3R/ouxDajp/PUEtAaUW0+GVrSD/4CJo+I1h6u55QmoPAMpu1TICjH6rBii4ogkU0eXhvq0jElR9r4caVteIKgPLvCWX9FGNacw1yAktwA0zeRlCIFb6vdRuHRhax0hJQ/LVqLdcR0RJ8YLJrJCf3aKM5CKzmnCKMi4trpB4RdaH/J5KIakKnu+EdjNVg8MOL1+DFrQCOc1v5x11py8BErbkGwxW1h6L1l7TGKEHV6XXs3LJcUAncOZXLpjqXtSNgofeFUoTRRnMQWM21yJ1sGpouJLCIJklwkmaPx1MP49BCeDABfmF2wPtJIXwMXHs1WwY+EsSfIxKndq2aq9OJWPH94gUQf06t5XoKLpmjvT5ThAAVuUcrzbkGi1KETRcSWEST43S8rfxYATfGggkbQ9byAotHWT/FFEKGr5c6HYFVz5or1WPWHbHSFlz8V71+Akx2fMEDgOlSYOmV5iCwmmuKkIrcmy5U5E40KYIpwci9rTzw4UWI2AwI5dxWPq3GCwKlLQMY/5XgxVEkRe1111wpRgkGU4JCaP+0rB54QcSfU0tQ8duVES353eJSjga1VCnRFAkKYT0LkOYssMimoemi/yeSiAqCKUG3210Pb6uD8OA6+IVPoB5Z4oUPV1wuuBQF6tpzDSoFVv2L2hsiYsX3m1/m+6C1XLfg4kdgGgxe3UWw9HY9QYLXRRGs6IdShNGF/p9IoskTmhIEtL2tAMCH7+HB1WDC7lNrlAJLUHg78UIHAPi//HiBxU8T4+PqkQDtovZIUoJ8tI0/plYEq74CS0ugadRsCR7dChK9QQJLP1CKMLqgFCHRaJyet1U1vHgaDEcBwRmyXi11p23LwPtJCYL2SMNAbVfoeq20YiQCSy4GldPraAmiM6V+ES2DwaNiyhr96FGEkMDSD2qjJSmC1XTR/xNJNEmCKcE9e/bgwIEDEYkrEbvhwdUQhe+gfHQjEVhqYokXNlw/VVOPfLSpbiNRpQ2DT6XWSysqVt+vKh9d0oo21a+Gi2qwoofmIrDIpoFoalAEi/jTCUatRFGEz+eLaIi1F5/AjxdPjWADVAvWFYXikdgycGlERTfUok31rbkKJ9JCndj5Y2qlAHm0BFXDCq5AilD/ztl6oLkILD1fXxBeYHk8Hng8HopgNVEogkX8aTDG4Pf7JW8rQRBgMpng96vVRp3aB2XwYDL8eDtEXAW2yBAYlLYM/A+udoG6IEQyapCv7dIyI9WuudIuYufhBRLf7/ou88fjronJBV8gRUg1WNFAcxFYek8RBn8/Q6+zuroaAEhgNVH0/UQSTQZ+uptgIbvRaAwrsERsgBtXQRSWQJmWU9uHF1gR2DJo1k+piTJeDJ2OkajWhNBaL0MtwcTfHy1BpYUygqU39CoYRTHw2ZPAim4YC3jPhUawnM7Ab5rDoeX5RzQGlCIkzjrBlKCaI7vBYFAILAYRfsyGD28FJjoGoBRYyomalVYHfJSrRiWNyI+O4+caFAFmD+wbZh9NgSX4VCZr1po7kH8Zagkq/n7wAktrO388vjsCt0gRrGhB7yajasJDjwR/J0Ovs7q6Gg6HQ/fiMlohgUWcNYIh7boc2Y1Go/QXNgAwFMOHV+AXvpW1E2DhZIxaBIUXWOFsGapClvnITLiRhqECq26vLBY2JVh7bO1Rgjy8mOGvrb6CSmuZ1bko6DRFqEchoneB1RwidIC6wCKLhqYNyV7irBCpt1VoitCP5XBjLERsVTki/7eAmu8VHxUKJ5bke2kdVync+K/N6RiJakWstAQVL6D4Zf7a+WW+vUaEjOueYNBfilCvNBeBpfcojloGgCwamjYUwSIanGDUKhJHdqPRCL/ohhcvwI+5gMDAGF+fBPCPqnqUKBLfK600YgQjDTWL2iMpjK9vSlBLYMkFD6u3wOKX6y56F6A/J3e9QgJLH4SzaKD6q6YLCSyiwQh6W/l8gZd1JI7sRlMh2nV+D37ZJM1qxej8j2ckBeuRiCVeJERiy8DD11x5AqPuhFBRpGXDoDUqUEtQ8RGl+m2vb8pQMLh1J7D0KkT0el1BmrvAoghW00XfTyTxpxGcpDkoriIxDvXjRziSboHJzE/SXK3Smj+WmsCSt1GLcinTiLyQUB5Xa9SgUrwAShsGLe8snrpTfspz8mKSXz7TCJdc8OlxFKFeaQ4CS+/iCiCBFY1QBIs4I0Knu4l0kmaGGvjwHPzCVxAEQBEIEXwAswUmYw7ZS97GrzK6LxIRxj/y/ATQfvj9JhiNoQJDY5+wRe2hxfS8SKtfSrD+gupMBVfdowxpFGH0QAJLH5DAij5IYBGnTbCQPVikHom48mMvfLgfTDgQeiSVlg7IhYuajYAD8non/jinNz+h32flBFbdowZPz+dKcVaNfp2poKqf4NKMYNEowqiBBJY+oGlyog/9P5XEWSE0JSgIQkTiyof58OJaMBzhj6bSmi/cVPO94tvwI998gKJgXnsyZ1HU2ofvi5qQ41OC/DF4cVJ3jZVSEHGijp/fUBABZuG2h/44awksXuBRijBaCVqk6JXmLrAogtV00f9TSTQowUL24HQ3kaUEK+DBvfAJT50apSf/QVBOTwMoI0BqIwK16qmAgO+V7Gxc35TRJyZqzbGnZiTKTbmjKbD4a+ZrrDQiToI/YF4qgx8hyd/DkO0agkuZMuQNWPVX5K5XKIKlD9QEFvlgNW30/1QSDUaot1U441AeP7bBg6sgCr+ErJVHngwGZXRKUIgFZcREiEiEadgyqAgsUVNghZu8ORSt7Hs9U4KCK+BCL6Megkpzu0ZES5D3V481WHq7niAksPSBmsByOp0ksJowVINFRER9vK0AgIHBj/fhx29gwlFuq/xFryawIvO94qNEkZiEas9PyBhfLyWPNimjS8HzhI6G1JpOx8dt5QVkOLPSGm65MmSZvx/8Mi+wrJBGbApiIMUoTRUkv0aBE4CUIoweSGDpA1EUKUUYZej/qSTOiNBJmiMXVyfgxW3wCS9DPfIkFz1Gk9rLmhcoanVO8sdXTfho2jIILoDxXwOtUYNqfeGFnJbPFS8qlRErpohY8VEyLQHFb+cjc/z20OPz95JShNEKCSx94PP5SGBFGfp/KonTJmi/UB/jUD9WBaa7EVadWqMtnoxGtTb8o6nmjcWLmEiiXGrRMnmdFtMsalezf9Dyuaq75kqt70w8UwHFC0Wt9iHLgpcTePLPSID+UoSAPkcRiqKoy+sK0lwEltp1ksBq2lCKkFAQ6m0V/OtXO2rlgw+vw49fAOFEyBa1dBonsExqbTgEN5fCUkNN+PAiLNz8hLWpNkFrn+CIvZC+KCdv5u8X72ulMSoQODVlUGi7ulOAAkyyPmgtKwWWXMAFatxO9YtPCapOKUQ0RSiCpQ/8fj9MJvlvJ9k0NG30/1QS9SJ0lGDk4uooPLgRfuE98KkypppOkx/PYPCBMV48qEVH+L/UePNRp0ohOC+WtKfPUV6tWoSNt4jQqrnSKmL3KUYFKiNY8u1KIcj3QSuiVUcEC4BcwHERLB0WuesVElj6IDhqOxSKYDVt9P9UEhET9Lbyer0Re1v58T+4cRWYsAWAWs1TJNPeAEzkBYua5QJfg6Rm71B/WwZF/RTXPfWidq1Rg1oCS7sfTBGh0hJMvODiv97yZUFTcIUKTz6CpT+BpbfrCUICSx+QTUP0of+nktDk9Lyt3PBiFrzCPYBQEbKFf0k7VYJRyhcZE3nBopYK5AvJIzEf1XZ354WL8tIjcWo/85orhWhT+FydmaBStteIgIWeXxDBThmZMmbDvv9eDiI6IIGlD8imIfqgGqxmzulMdyPiALx4IMxW7qUt+AHmgLw+SimMlClCZa2UACsnlyIRYdq2DIrUm8L4VG0fLbd3jZqrYEpQCL1O+TEZO1NBVT/BFUmNluhJw9LbbsSRRQlo/4E+Iz56gwSWPuAFFmMMVVVVVIPVhCGB1YwJpgQjtV8AAB++gg/PAUINBNZWpYXaMWIhFylK8SQqojVqablIfK944cPbMnhViuU5oSGoWTkIgFArKJRF7TyRpgRD23HXJ/BfT/4lwt/r+i5rRbjkn0n10f746fKLUZlvBiBC9KqlaKMbPQqR5iCw+MiOHuEFVnCqMopgNV1IYDVDGGOScWikjuwM1fDiPxCFBbJ1ai2V8Ok/laJxxhuLak/UHM73SjvKFQO5KShXm6RqfOqAvJ6soWquQo1C+RSdVsSqvi9NLcEVJmXIBBTljsWyOwaj+kjtZyc69fXyphqs6EQURZjNWrMvRD+8wKqqqgIAElhNGP3HVQkZodPdAJGmBHfCg6vAsIPboiawIplXUG16Gv5RVEvLRdKGFz5qtgx8nRY3qlEIZ+VQ13k0aq4imOpGUQtWb0HFCwQtwaAhuAQTfF4rtr56B368vB9MVnn//E59ChK9QZM9Rz9B65xQgeV0OiEIAux2/reJaCpQBKsZERq1isx+gcGPefDhZUDwQmB95A2EGpV0m9q8gvLaKbXolNK1PJLRh5EILDWLBb5OizuLIZJ96llzBSAg0kL7zKc85REkpeEpj5agqq/gkp/PV5WKH68fgRMrUwO9s8q3i9VM99ERPaD3z6g5CKxgjWyowAp6YOn5s4129P1UEgBqo1Y7d+7EsWPHIhJXIkrhxe3wCf8JKcRWq3Pgw9ORTHtTpd1pwQ8wjb/MBJdmGk3dloFPJ8ijT+oCS2vUIG8roW3DoLRd4GvB+P15gcRHzfjl+gqu2hO6jp2Hpbf9VRJXAGDgBZZTv2k1PUECK/pRE1hk0dD00fdTSUiF7D6fD9XV1XC5XBF4W62DFw9AFH7jtqg9LvwIFrXIDT+y0KWouQKLxNNKrQ2f7uNRs2XgI0fy4xqESPbh4UWZWnSNj4LVt4hdSyDx94cXfREUpTMBRb/9DZ92vxS+Knl/DUZ5f0Qdpgj1KERIYEU/fr9f8iYMQhYNTR99P5UE/H6/9OU0mUzSX0JqMPjhxevw4iYAhRGeQR5lisS5PQA//18kxqLa8wgqRYdaqrHuOi3B4AVT1ITx0SaNonbBoxJd40Ua3w+hjiVAKZD4+8HfQ61l+fGYz4TNL0zBj1f2UqkXAwQDJ7BOpQiJpg0JrOhHzQOruroaDofWH5hEY0I1WDon1JHdaDRKEzfzMBTBgwfBhI2BZaYWgVFGQJTeVJGOLHQgdCSfoDrHYCTGonwbro8R2DKoHdcv2mAyhN4Dfh9OnIStuQpNh9Zdc6VA4cfFCyS+33xxfuQCTHR1wLon/oKd79eu09JOYo2+UoR6upZQaLLn6Idc3KMTElg6J3SUYLgIlh9L4MUbgLA7ZK2aUFKLMvGPUHVAT8l+z9VSU1x0SmXkntJyIZLaqPrbMqilNUW/BTCFCqy6i9rD11zVCiztCaG5rQqBxV+b1rKW4Aoc33n0Qnw7fCQS2iUAOFnbG7+8P7wA8VfrU5DoDRpFGP2Ei2BFs8AKZlaC8H8E6OGPAn0/lYQMo9GoEFh+rIVXmKxMRwnVKimuCArYBRHKwnf1kYWhGAS1Y3OTH6uIGGVtVCS2DHLUok+inz8u/1Xhr0ktNapVc6VVY6UlsPhr5e+hlgDz4+ivf8dnvXJQc9wIv0d+Pt5IlPnk/ROdlCKMBvSeItS7gATUzVSDowijFaPRCIPBIP0LDr6KZBBWtEARrGaEyWQKmyJURoKAgFAKjfyopcHUftgckKfGtMWTYIigOD4C89HIbBm05ydUOsvzqBiJcm7v9U4J8qMZFWlT+bXxwpAptvP3ImRZTMD2ty7H2ifipVU+Fye+3fJl0UsCKxrRu8AKzp+qZ3w+n6rAiouLa6QenRmMMVx77bVITExEfHw84uLipH8pKSmIj49HTEwMYmJiEBcXh5iYGNjtdthsNlgsWgOOmg4ksHRO6A+rWgRLQPAFG86CoVZgMdWRceHqq0JRE0/yR89oVEux8T+aamlL3jsqkil2+MiQii+XqOXUzs8tyBRzLipTnPz18MfkBBUnsOoUTGp9UgiwgCj013TGwquvRfXRFFl/fTXyZ0MhuPgIl9rHEeXoUYjoXWA1hxSh3iJYNTU1+Oqrr05rX4fDIbnYN3VIYDUj1IrcBSSc+j+1Hyh+FF9kBewCbJrGovz5DEa3SgSIP3BNIG0pmytQ23xUWfukNteg/LhKZ/lIitpt3Pm1UoJaKUAtAcWLUn5ZKbiqD1+Mb0YMg/ukEbZk+fm8VXUv8wKMIljRgd4FVnNIEYarwUpISAizR9PGarVixYoV8Hg8cDqdcLvdKC4uxqxZs1BRUYE+ffogLS0NZrMZBw4cwK5du1BWVoauXbuidevWjd39iCGB1YxQL3IPfkHVhJLKCEFFAbtaypFPr2m7sgsCA1gs5KnFcNGxSpX1QU53+pwYABW1Z1YIrEiK2rWm0+HhjykXVIKi8F9bQIVdZiYcWfgX/O/6zrVnq5Af31PJLfMCq5oXWPoaeaenawlF7wKrOUSw1NKg1dXVaNWqVSP16MwwGo04//zzZevmzJmDmpoavP3227j88stl2woLCzFlyhT8/vvv+O9///tndvWM0PdTSUSQIow5Zfqp9nLhhJLgh9J3Sk2s8ALLqXL4SCaFVhu1yKcfueOourtHUqwvr0FjimgTLyTVhJxWYbxGSlDhpaUhoASf3LBVYACzKrYzMQnrHr8b/7u+MwRz7XWJPgaTo/beiF4Go6O2zz6nX3br+IiWnyJYUYGeBVZwjr7mILBMJvkfbNE+ilAURSmjsnfvXjz66KMYP348Lr/8cni9Xvj9fqlNRkYG3nzzTVRXV+OZZ55p5J5Hjr6fSkJG+CL3eKgLJbUIDC+wIqidEvxQCqNIxJNaXyMxH617MufwnlUhbRTOEqdjJFp3mpHvu7LGiru3vKACoLwfcqHoq+yF70dNxva3kwNbE+Ti1xInP54lVn4NhpDD+90iDJYQgaZDJ3c9oucUmigGvlN6vb4g4SJY0SywDAaDlPYsLS3FiRMn0Lt3bwCQfBtD25hMJmRnZ2PVqlWN1uf6ou+nkgBQG8VSi2ABwTosNYEViQN7pM7t2tYNypGMp+t7xYsOvj9qopA/Li8e1PoivxfKuQW15iusOwUoCG4Vs09ePPL9rh0xWXngEnw97G84vql2nSVGLqjMimW5aDTa5T8R5tja9swF+H0RTL9DNCp6j2ABzUNg6anInSc448jGjQGj69BoXfDZLS8vx/79+6NqFKG+n0pCRrAGS5nWSYC6BYIS3r8qcud2XvSoCBbGf3GUkabIfK/4c/H9USuE547LFdurTxrN2z/wES3+vH5uq1bROuBX+HHx959ftgDMhEPfTMQX5w6FwSDfHpoSBACTnRNYdvl2g03+YjY75O095Wr3P3rRoxDRs8BqThEsvRmNArXft7Zt22LQoEF44403MH/+fOTn56OiogI1NTVwOp04ceIE3nvvPezZswdDhw5t5F5HDhW5NyOCX1A+ny8gHiIKVPZQS+PxL3y1wne1/XghoO17pR4d4x9ZtePw5+L7U6PSZ/lxlS7qkUS9tKwdeDHC11QpvbREvxkwhYpR/v7Ll5mnBdY8eh12zUkM9IgTRCYrZ49hlb+YjDb5ZxBasxU4nny7pyKcrxrRVNCzwApG5PV6fUH0KrCCtGrVCtOmTcP111+Pv//97+jXrx/69++PhIQE/PHHH1i+fDkKCwtx2WWXYfLkyY3d3YghgdUMEAQBjDHpC+rz+biCyQTIR+8FUXt58s7tfoDFQB7JUndul1s3KKNIjBm5pJpaITkvwtTc3bVsGUSA2SGP2nHCQiGw1PrCCywtGwatUYFAICpW2y9R5NOOvMCq3e6r7Ill/7wWh3+pPa/RwtlhWOR9NJi57SZ+u3yZF2T8SMRoRq8F+3oWWMH6Mr1eX5DmMBfh6NGj8d133+Gll17Ctm3bMH/+fHi9XphMJjgcDkyZMgX//ve/kZKS0thdjRgSWM2I4JQEypGECYDgVPGYUqs7UjMkdUAusLSNRdUEC2O8RFGLjvE/pGopSl6UhJs+J1RgyYWDIPCizKOYNFp7bsH6pwQD6c0QgeXnr4VzwIcJDED5nkvx7SVDkJydAKBU2s4LKMHI+48JdS4L3MdtsOhXYOkVPU/23BxGEALqAsvpdOqmBuvQoUM4ePAgLrzwQnzzzTfYsWMHDh8+DJfLhRYtWqB///5RKSZJYDUz1Avdg15YcQDKQtarCQA1YgAcD1mOZNobFfHERxAEUeGOHsk0N5HZMvD1U5zQMIQrng/14NJKCfLHULNZMHMTXcujYqLIRdY4UcdEKw58cQuWTW4PQCVixQsm/l3Ev3cN3AquPX88vaUI9ShE9BzBaq4CizGmiwhW8Lrmz5+Pzz//HLNnz8agQYPQs2dP9OzZs7G7d8bo/8kkFF5YSjf34HQ5/AjByJ3b5S3U0mncD7zAwI8sZIqUmrJPSt8rH8DqFkuRFahzk9oYIyme1xJYGrYLqv3g/Ljq8PRivpbY8MwVkrgCAIEXSDxcF5nIr5AvCrwhrIEXWBTBauroWWA1h3kIAaXAcrlcEEUx6gVWMC1/5MgRVFZWStfj8/nAWPT77On/ySRkqLm5106XwwsItbostQL2SJzb1ZBbDjCm9rLmBYiaCKvb90otyqUcjSj/IhtVBZbWqMHTrbkKRX4vmcL3KnBOb3lvfH3h7Ti+PkPlmKH7c8t+bnSkv+7tqgNCQ9BbBEuP6Flg6dnjKxReYDmdgT9io11gBT+7vn37wuVyoaioCEDgPSUIQtQ/t/p/MgkZdaUIFRYMQo2KsaVauo13fHeqmHCerrEoL0AaxpZBKQrl/TMaI/Hg4tGouQqmBGXIr4/30mKM/4oaULr9cnzadRzK8swA9wPER6REzqfK7+UmbPbWvV0hwLjjeyv1I7Ci/a/lcOhZYDWHFCFjTCGwqqqqYDAYYLVq/SY1bYKf3fXXX4/Bgwfjs88+w4EDB8IYYkcfVIPVDAj9cVVzc6+NYKkZuMUhtGhavb5K7QdOPrdfRMaiglLUKOdDVBM+GlPsqEzmrIw+yftnMHoCRfch7yXtonb+GsMVsYeKRP6e81/JkHvLbNj/+QVYdmdqyDp5a9HHCSwPJ6Dc8mWf289t50QiF9ESuWUvRbCaPCSwopug11eowApaNET75xr8/L744guUlZXh66+/xrZt23DFFVegQ4cOSEpKgsPhgMPhQExMDMxmM9q2bRs1wpIEVjOj7iL3cCMEawVW5M7tvMBSRp4EWGT6QFAVJNq+V/xxwkfLQgvU+WuV908QGJhoD0TxJPjok1bNldq9siH0vihFm3oVOvNl4Lc7/wFnQXsAJ6Stop+LSHGCyueS3wtfDTeBs5Pfzh3PXbdg8+gogqVX9CywmkMNlprA0kOBO1AbNX7//fexatUqZGZmYteuXdiwYUPYfVavXo3Bgwf/WV08I0hgNTPUI1jx0v8p4aNDp+vcHoF1g0FNYJ2O+Wi4NGKowOKvVRkZY8wGoQ6vLGXNFXcMwQ0wQ2A0pAT/lxcv2vhzCKg53hs/XHolKn43I2MwJyW1BBUnoLxV/LL8WfBWy5d5gcVHwPRWg6VHIaJngdUcarCCv9eh16kXi4agaHzxxRdRUFAAj8cDt9sNt9sNl8uFmpoa1NTUwOVywe12o7CwEK1atWrkXkcOCaxmAD+KMHwES22EIJ+ii6zwXWksqm2nYBDUaqX4H081gReJuzsv+OSojTRkitGJdU/erD5a0QH5PeNTgrygkp+jaG1nrJ4wGKI3sJ5PAfo5QcULJE+VXGx6Kute9nLtRZf8fLyA81aqRQuJpoSeRUhzSREajUbZ77ie5iEEEDURqfpCAquZoW7TYD7lNxXB1DiCL+CCLkudqUWMVKbUUcBbACjNPJU4VcxH5T+w6kKHjxxpT4XDFAXpp1NzZUOowFKmM8O8HJgdu96ZiK2ftIPorb2/fMTKWy3/zPiUHR9h8tX4IZgFMG+gF363CINVkCJV3mo/BGNtcbu/mouQ8REwnUWw9IieI1jNQWA1Bxd3URTh9/thNvO/udENCaxmhslkQk2NWjQpAepCSa0uKxby+qJInNsjTS3GQm52ygkhgalMzcO/PCKZPkd7KhylwOKJpOZKKyWofDkwb2ssvukGHP4pFo4uXATJyaX0uBSfp9IbuB2ndmN+BnOsUZYatCaY4TpR23drnAU17trP0BJvhrs08CwwHyBYAHaquYdPKeqoBotGEUYfzUVg8dfodDp1JbCCs4wcPXoUx44dg9/vh81mQ2xsLOx2O6xWK2w2G2w2W1Q9yySwmhnqKcJgHZbaCD21h5m3V1CL3PDGon6VyFc4T6syjTa8wOJfjJGkETlhILiVIw0VFhUaRe2CVyUCxwssZY1VKM6CNHx36RhU/RE4N28NxqcA3bzRJwMs8SZZ5MoSb5YJLEuMSSawzLFG1NTWzcMcWyuwAssmeE4Gjid6uIgXpQibPCSwohu/38/NHau/FCEAfPTRR/jggw+wefNmeL1eeDweMMZgNpsRExMDq9UKQRCQn5+vuB9NFX0/mQQAbSd3IGDVoF4npfZX/Wk4twPgndvVrRv4WqnTMB8V3CriKJJCeM74VKy7qF05tyDA919paBouJSigOPdqLLn1MklcAYDo4UwqOEEVjFCFYomXR8nMMfJrN9nl7c0O+XYzt93okPfZEhsywbTTr3SDJ5oUJLCiG7UIVlVVFeLi4hqpRw3Pt99+i4kTJ6KkpARjxoyBx+NB9+7dMWDAAKSkpKCiogJWqxVxcXFRI64AEljNDjUn9wAJUI/8KCNICkPSCPeLRDwpBUkk8whGYmKqPWqQ7x877ZqrUOrwtTp1FrAYbHt1Mr4f0we+Gi6RyS17q/0QuEMqBBUnmIxWTjDxAsoq75PJzi3b5Msywcb0NV2OHoUICazoRq0GS08RLJfLhWeeeQbt27fHokWL8Nlnn4ExhilTpmDdunVYtmwZhg0bho4dO2LXrl2N3d16oe8nk1BQd4pQbYSgWpSJe8MLLhWHcjWBxYsPtQgQL7DUfa/kaEejTmd+Qsa0BFY4n6tQ6v5ry1dtx//+dg/WP5MOQDkq0F+tjA5ZE+TXz0eojDZeIHGCysyN3uSXLdwE02b5feAjYG4qdG+yBOdzI4EVvYQTWHqpwaqsrMS2bdswbtw4pKen48iRIwAA96m60C5duuCTTz7Btm3b8PzzzzdmV+uNvp9MAoC2k3uAhICTusKaIFLndj5crebKLhcGkVg3ROZ7FUmUixcq2gXpyqJnTsgJroDPlQytlGDtMWuKzsOSm6/CkUW1YpAvIhfdDAKnXS2xfMqPW+YiVgYTN1rTyC9zPea3cwLLYOUmfC7XTwRLbwSfYRJY0YveBVZVVRUYY8jKygIAeE+Nmg79/XU4HDjvvPPw3XffNUofTxd9P5mERPAHNnwEK+iFxX9pIyhgB6CMGEUyslCtdouve9Juox6N4oWO9qhBrQmg1a9Jft3aNVcMYAIKl/8N/+1xKaoL5feE96UCAkXmoZj4FKBFQ0AZ+GVobK+7vZGLcOklRajHUYQksKIfvQssr9eLlJQUKWLl9XrhcDikSFYQj8eDqiq1LEvTRd9PJqGgzggWAEWhd8T2CnzheyTT3qgdm6da5XT8y0IZjVIKHX5+QrfKhNR8/yIxEuUjZXV7ZzGfAZufn4KfxvYCmKAYFeit9ClqrIwxdddEGUzyZV5gKeDvp5au4AeEcsd3UwSryUICK/rRu8Cy2WxIS0vDqlWrAAAxMTHo3r07vv/+e/zxxx+oqanBunXrsGjRIvTu3buRe1s/9P1kEgqCESz+r/Xa6XL4QvTIndvlRDCyMGhaKoN72wsMyqga/7JQO1f9Rw0qo2f8dUYisMJ/pURXB6z+11hsejGttldVSrHL11jxNU8GMyeouIgTH4jhR/nxEzgrlvlRgdwidzrUHFeL7BFNARJY0Y+awNLLVDkAkJqaiuuuuw6JiYkAgIyMDEyaNAl79+5Fz549ccEFF2DUqFFo1aoVbrjhhsbtbD2JnvGOxBkhCAIYY9IXVemtEohgKabGEVwq3k6ROLerCTO1UIkD8ghUOG+s0OPxIqxGZc4/XiyFGzUYOj8hnzvjxY+akNPyuQr0yXn0Inw7fATsLWIROtmzu1zZL0usCa6S2vUGLgVoMNb9QuEFk2J6Ha9Y5zLfXiHYuHd11R9q9WzRid6ECAms6EfvTu52ux133HEHysvL4Xa7YbVa8fe//x0lJSWYM2cOCgoKMHDgQDzyyCO47LLLomrQBgmsZkZQVPECq7YGS+2RiAdwMmRZTazw4sQTGFkohIqxcOKpJGQ53ETNoajZMsiFi3L6nEjmJ+RqjwS+qN0HMEvg2qQ9+KlvuC8+Yzj66/VYeF03AIDJzhWxexlMMUb4Qqa84UcF8ilD/hQiL6h4AcVNr8NP2KxY5toHp9WRlrnbX3lETXgSTQESWNGP3lOEAJCcnIzk5GQAgWfWbrdj6tSpmDp1qqJtND3L+n4yCQUGgwGCINQx4bPaI8HXZalFLCIZWahW+8Wn2CIxFo3kODyRTGPDSSVeYAFQphXrUD9iIna8PUoSV4B6Ebs1QV63ZeRsFVQ0m3zZxwsmzuqhRr7sq+HnJ5Qv81YRvGATOQFWRQKryUICK/rRq8AKPpvbt2/Hyy+/jM2bNwOozbaIoghRDPzW+P1+eDxqf9g3bfT9ZBKqqBW610aw1H6I+UhPpIXvvBhRMxblrBHCzCMoR9skNBJbBuVxuWmYDZGcR306HX9NZ/xw+V3Y+1mmbKun3Ku4xXzEiq+xUggsTlD5XNwyJ6g8fCE9P2EzN2G016m0ipAdjxs1WHlEHylCvY4iFASBBFYUo1ej0eAf+d9//z0efPBB3HzzzVi6dCmAgMgKBgMA4MCBA7jgggswbdq0Ruvv6aDvJ5OQ4KfLUUawYk+Nqjtd53btkYWRWTeoFZLzQkjtOHwf+etzqnSRP7d8H8EQyXn4r5CI6sMX47OeN+LYGpss9QcATFRzXueK2LlRenxNlc/NCypuwmfFhMxyQcRH0fhlfmSjv0Z+PidX1F5zwg2fi+YkbIpEU73K6dAcBJYoijKBJYqiLiJYQUpLS2EymbBr1y7ceOON+PHHH6VtwQhWTU0Njhw5Ii1HC/p+MglV1CNYAgIpPbUXJSdwBHegFklGJNEpbWNRdfHG11OpRbn4/vCTOTNojxqU72Osr8BiJvyxqD/m9x0Bd2lgvVpKkBdY/FQ2PIwvUufEjEJQVagIrpB3rK/GLyuc9znl0+94KvjjcRGuSh/M8fLpcvRS6K43MUICK/rx+XwygVVTUwPGmG4E1vHjx9G5c2e89NJLMJvNuOGGG/DFF18AgHTdbrcbbrcbCQkJdR2qyaHvJ5NQpe7pctTSYmoCgP9yq+3HR54iEU9q9Tz8Y6rWhj9XJPVT/HHl+wgGv0JICmHGhTAxGeseuxsbnpP7tKh5RCmK2PmIFWeT4OcmfOYjTLyTus/ll7utM6Wos8bLryvUGoL5A4X3QUQ3gzVZvr8jVS40qdC9aUICK/rhI1hOZ+C7Fu0pwiCVlZWwWCz4xz/+gQULFiA5ORkTJkzAhx9+KLVxu93weDxRN8G1vp9MQoJPEaqbjSZCPf2m9gPNf7nV9oskOsUXlvtVvLF4IhFhkdRPRTIBNH+dyporX3U3fD/qTmyfnQwfJ36Yn8ESzzmxc5Mp8z5WvE2CyNVY8TVQfreomL7GEicXUHwfzDFGblm+3RLHCaoW8nQvL9j0EMHScw2WXmkOAouvwaqqqoLJZILFwkfto5OqqirY7XaUlZVhwIAB+PTTT9G9e3fceuutmDVrFoCAu7vH44m6CBbZNDRDTCZT2OlyRBxX2UPtxWPnWkQwsjAonoTQtmrHjkGd3lhBg1LZcfhImFp/6p4KJzKndrkwKd/bFt+O6g1v5amUoIpxqCXBLEu7GbkidsZdHp8C9Dk5gVXlC1xuyGpLnAUutztk2QTXidplMz9foYMXffJla7wZzqLa+2GJ46bnscqvgUYSNk30LLCCI830LLCC1xgqsIL1V3r5XIPXE4zIDR48GPPmzcOdd96Je+65B2azGenp6fD7/YiPj9c4WtNCv08mEZZwKcKA35ValElNjPFiJZJpbwBlalEtksZHmsL5Z9WF2qhBvn6KP66aKAvj1M5MOPjlTfjtruGSuALUJz42O+TRHn5qG+bnRwVyNgvVXD9ZQACFwgsgM+f+buSm1+GX+agaH6EyWOv+qajUQQRLj+hdYAHQtcAK/k6rCaxoJ/hcFhcXQxAE6Rq9Xi969uyJTz75BCNGjMCdd96Jl19+GYyxqItg6ffJJGREkiIMWDVUqQSV1EQQX/Oktp+aiOPF0+l6Y/ECS3syZ2WfVUYaau4jgPlbYPX992LJPzsqLBF8Lj+MnFgxOer+mvHGnp5KpU0CnwI0cyk8xQTQnJeWiSukN5q5ZYuhzmX+9vq5tGXVHxTBaoqIoqhbgRUcUdYcBFboNerBogGofSd1794dvXv3htUa+APYbDZDFEVkZWXhyy+/xKWXXorc3FwAkKbTiRYoRdgMCZciBOID082wWMinpomgvkpgAIuDfOoZtXNoWzcoputRrY3SiEYJHpUpfuoeNai2D+/U7i5Jxo9XXYqTOwIRPK9TeY3WBAucNbXpNUVKkBOivEhTK4znU4BmPsXHRZgUE0BrTAitiKrxfeRHLurUC0tvYkTPEazmIrCCnlBB9CKwgtf0zDPPICYmBjZb4N3AGIPBYIAoikhISMA333yDhx56CGvXrkWLFi0as8v1hgRWM8RoNMLtVhM2wfArL7DUapPCFb6HCiw16wa5YFGve9L2xlKKMLVIWAyA8pDlSAvhQ6+hti/luy9D7iNjcHJHae0RKlTEUKxJFgszmLgids4ZnZ/w2X9qFGCowSdfU8Wn9HhzUgN3C/l3rMDdCj74yHtrucvk18l7YTmPueD3iMrIF9GoNAeBpdfrA/Q/DyEA9OrVS7Yc/DyDAsxiseC111770/vVEJDAaiaE/giZTCZUV6vVTAUFFl/Arpb+icRYNBLxpHZs+Q+KesE6f5xwacRQgRXJqEEHZAKLGQBYsP+/E7B8Sluk9ZO3VrVhcPB9k5+Xn8qGTwkCARuFmuPhI1Z8VIw3J1UXwCFwH5/I9UkhqIrkn6W30gdjjAB/NZOOV3W0Bgnto/cvaxpFGF0EC9z1en2AusByOp26iGAFCV4jYwwFBQVwuVwwm82wWq2wWCwwmUzSqEn+XjR1SGA1Q8L7YCWc+q+Ne/9WKtqqO77buehUJMJI2xtLXYTxx1FLY/KCjx81qF3U7nPFYtWD92Lf/MDoFT6dF7RhkI0StPLpNs7HyskLLK/KqECTTGDxxzSY636pKOYr5Ly1RG66HV4oOo/JBZXP5Yc12Qz3ydp25mQT/NW1y1VHnFEtsPRIcxBYekav8xCGYjQasWTJEvzf//0fNmzYAADweDwwGo2IiYlBTEwMzGYzTCYT5s+fH1XPMwmsZoiakzsQNBoFFHYGQed2ITTioxYx4gvC1YQRn6tyA8wMqE6sHHIcJpxyYw9yOrYMvChUi7DV1naVHOmA7U/+BQe+qW3Hm3wCgCXBIhNYfL2TIiXIR6wYYEuywHWy9v6aHHUXofP3kRdQ/MhEfoJm/joUgqrGD1uKBa6S2j7ZUixygRVrhCvkOSCz0aYHCazopjmkCHNzczF+/HhUVlbinHPOwbp165Camgq73Y6SkhJUV1fDZDLBbDZH3bOs76eTUCW8TUMwRaimuyNxbo8kOqWWhuGPzResM5U2PGq2DLzA0h41GJwA+uTWv+D/zp2AqqPydKlqzRVn2snXN/Ej7twVynvH2yzwo/54M1I+Ksabk/r5+Qo5gVVzXN4HT6VPYUbqSOXMRbk+hk63A+jDbFRvkMCKbvQewXK73XjyySfh8Xjw448/4ocffgAAPPzww1i3bh3eeOMNdOzYEePHj8ehQ4cat7Ongb6fTkIicpsGQP2x4FM/atEffmShT8WVPRJPq0jsHXihpibmeMHHjxr0AYybL1F0YM/7k/DNxQPBPEaFcPFUeBW3h7dI4KNJXidfxC6qWDlw4sVc91dTMT+hp24vLR/XB+dxl0IgOdLkgsrMCypFn+T7l+ysqLPP0YDexAgJrOgmXA2WXgRWeXk5li9fjmuuuQYXX3yxNPjKZrMhLS0NEyZMwBdffIHPP/8cv/76ayP3tv7o++kkZAR/aMPbNNRl4sYXvjeksShfK3Ua5qMqYimyUYO1wpH5MrF+2uVYNbVNbU/4misRsCZwJpy8DQMvylSL2DkfK7tGxIqfn5BLOyrd3+XLzmKuRo0BMS3l95S/Li17CcaJusI1JRD9+isUj2ZIYEU3eo9gVVRUwOPxoE+fPgAgDb4KfWbbt2+Piy66CHPnzm2EHp4Z+n46CVXCF7lbAWZDZM7tVYo26uk/PjqlZt3AC6NICtbD2TKEEonAChzXc3IAvhx8G05sbSnbqlZzxYsjfgSfz113ATmgnOtPK2IlejlTCk74KSaArpSf01vlgzVJfk5bsvwzNXJpSYWo489ZpawtK9lejmiFRhFGF81VYOmhBiv4XfN4PIiPj5eWvV4vTCYTiouLpbZGoxEWiwWFhYWN0tczQd9PJ6FKMEWo/kKJR0TO7YIrYMopQ22/SMQTXxyv5nvFCzy1ovi6J4kON2rwxIax+LTbX1Hxu1kRpVEUpEM5MTIPL35Ej6goWucjVrxIY36+pqruCBVfG+ap8CrGE/A1VXwf+OdBywDVXexVZGELVp0A0XQImjbqkeYqsPSUIjSbzUhNTcW2bdsABDyv2rZti6VLl8LtdkMURezduxdr165Fx44dG7m39UffTychIzRFCNQa9cnaIAHqkR41/5E4blmtrourcYrAuiEye4dIolwacw0yO/a8/1f836j+EL2Be6NI76kUtfPT0PBiiI8eAYA1kUu/2er2c+FtFLw1KtYOocvBCaCDfRIBR5r83lu4FCCfhuSL8V2l8ueg5pj8notuBkeWXPiSwGpaUAQruuEnegb04eQefCbT0tIwYsQInDx5EgDQunVr/P3vf8fy5cuRk5OD++67D9deey3cbjeuuOKKxuzyaUE2Dc2QoMBS++soEMEqUdlL7UfaAaA0ZFlN9JyO75VaG958VD3KxY2t41rUjhoUPW2w5Obr4SrOAnBSWs9Hipg/IExCJ3HmLRP4eijepBNQRr0UU9Nw6Tifi0+/qUSoZAcI1FCFntvewgZniCjia6r4fvOCirdu8LtFWFPMcJfUnsMUJz/msXUnIfpExfURjQMJrOjG5/NJc/QF0UOKMDhHZmxsLO655x4UFhbC6XTC4XDglltuwe7du7F06VJs3LgRsbGxePDBB3HLLbc0drfrDQmsZoggCBAEAT6fDxaLPAIhIBEijqjspZZO5Avf1SJPvICLoDheqAGYERBCxQ7/kohkYmZ+1KAfYDa4TvTG/424FFV/mJAxhKufqlHWn1nj5QKLj/zw+/hdfhhtBllESFnELj+HImLF1VS5K+TLTITC4NQSJxdY5lguMsjqjs5FIqhi0u2yZV8l328/jm8pQ8sByYhG9CZGSGBFN+EiWNEusIKfm9FoRLdu3dCtWzdpW1ZWFr744gv8/vvvKCsrQ5cuXaL2eklgNSOCP7SCIGi4uasVsKsXxctf2ZEYi/oD1g1CqBgLVxyv5iAfJBJbBi7VyQQUrbwaP13VBcwf+ILzYkktvccLFb6/qoXwCWY4XSHRIz4lyF0y71sV2fyEZrnASjAjVBvzcyDydVs13MhCNXNRa7JcYJnj5NdRk+9R9KtgVUlUCiw9FrkHIwV6pDkILJ/Pp7upcvLy8rBx40YkJSXBYrHAYrHAarXCarXCZrNJ65KTk5Geng4gUAzPBwOiARJYzZRwbu5APCA4VSJIakXlpzuyMBbyeig1y4hYyAUWb8vgVXGXr2PUIIvFtlcmIu/TjmD+EHHGHdZVqrxOPvokcrdN1Xw0zixLzxmMnLs7V+vFT5/jVjmmYn5CLu1o4YQg7yAf6hQPBFKCJodRJrzsLawygcWfo/RomWyZ+YDkbnEo2V7rgbV/fxn6KnpPNAYUwYpu1K4xWlOEwWv58ssv8e9//xsJCQFbILPZDIfDgaSkJAiCAMYY7HY7LBYL7HY74uLiUF1djVtuuQVXXXVVI19F/SCB1UzRmo8wUMBeFrJFrfCd+3ETPAEvKiE0MqJmLMqP9lMTb/zow3Ai7GTIMjcS71Sdluhuh1+vH48/lsSgRU/5I+/3Kf2kjHYD/DW163kLBb9HZQSfAJmWVKQEuXccbwzKj1YMjjwMFT/mWPn8hFreWXwUrPqYS9FPR0sbKg7WCk4Lb0HBmZF6Cljgown5iIVTYwsMZgEnetvw6mdb0WpcBs4b1hpE40ICK7rx+/1SzSwQuOZoHUUYfA779++Pm266CRaLRfLBOnLkiDRFTkZGBoqKiuB2u+F2u8EYQ2lpKYYOHdrIV1B/SGA1U8K5uUOajzAGoQJLvb4qnON7qMBSE0/8aD+leFNOOB2JLQMfLatBTdH5+ObiUag5FhAjRk6U8AadAGBLtKC6prYeSeFzpWY+miivf9JKCfpq+Borlelz4s1ygcW5vfPn4CNWNSe4UX8eEY6WVllkzZZkkQksvhC++gT3ufuBhGwHynfVpoMrCishxACrkyqxJrcIADBrxsaoFFh6EyMksKIbv98vu0anM/C9i2aBlZOTgxEjRoAxBq/Xi5iYGCxevBhXX3017rnnHjzyyCM4fPiwtN3r9aKyshLt27dv5CuoPySwmhGhP7Th3NxrI1i8eInUuT0G8qiSmrEoP9pPbfQhn35Ui6DxUa6QozIDCpZdip+v7h6YKPoURq4uSa1+SlEczm3nI0NAQAzJBBZ3Hq0i9uD0OaGRM0ucCc6i2jYmm/xlwgs/Pq3oPO5W1EfxIwv5Y/KjGZ2HPYGPIuT22xNsKA+pt/P7BfwSX4ZdB2tF6baNx/HWKz/j7zcNQWJiIojGQe8CKzS6o0f4kd5Bp/NorsESBAFmcyBSHqyrslqtcLvdaNWqFQRBQLt27Rqxhw2Hvp9OIixaEz4rI0iRFb4rhZnanIW8gFErjudHH6rZMvBF9qdEixiHTc/fhM0vpSlG2oEvaq9QEVhc3RHvjaXqzM4XwnMvNd7dXe281ngznDWhKUD5MQXO+kARsTqunA4nNt2OisO191fRT9SdVoQfsGQZ4DlYe67Q8xg6GDGvqATteiQB+UWyXb/5+DjaZ2+A9ZSIy8zMRNeuXUH8eehdYDWHCFaowKqqqoLFYpEESrQT/AydTid8Pp8kHNUthKIPEljNFO0Jn3nndrX6KrX95dGpyExDI/G9UjuO0pZBdHXEwr9dh8IVAaFnTbTIxAwfoXGXKSNjRguXRvTyU8T4IJgFsJDpa7RTgipGoQbIStTMsWYg1LeK89viRwXyIx5dJ5VF69YkCxAisAR+ZCGXIi3dVxn4eEI+WqNdvk/FQSdMsUZUZzG8t6MQPj9D5abjSE6x4WRJrRAuyPfg/ZeO459TU2G2GFBQUICCgoJAv6xW9OvXD3Z73e77fyZ6HEVIAit6YYypRrCiMT0YjuCz6Xa74fP5pMJ3vTyz+n06CQWRpAhrJ3xW++uB/2Krpe140aMW+eKtG5wA4x/FSHyv5EKt+o8sfHbOPyRxBaiNrOOsSH1M4XBu4PQfb28AANYEeQqTL4RXpASrlMagtkT5MczcdDrKY3LpOz5iBSAmnZsOh6/T0ojG+d0izJmcw3s5P8szQ0EXL97eGhBXAOB2+dGuczx49myrxjdzfTh3wAXIysqqPa/bjdzcXCxZsgRLly7FwYMHFfsSZw4JrOglONNGqMCKdosGIHBdfr8foihKf+TX1AT+gA5em17+2KEIVjMlfAQrXvo/JQ7IXd7V0n+8MHMGaqAEeVxLSQzktgxcm6AIE0KFy6kfV2bEH7+Ox6oH+8LFFWXzI+34iA2gNBLVTJsBsMab4DoRasPAiRJulKCau7slziSzTuAnW+bfi3zdlqvEA6PDAL+z9lwB4VcbEdQaWegsqlGMLLQnWeHNr/1svUUMplgDfFUiBBuwqaUTewuU4m7H5hK0ahODo0fkEckVi/7AFUMW4OHnBmP0lcMD53U6sXnzZmmU0MGDByWR5XA40KdPH9hs/GAIor6QwIpegn8A8ynCaI9ghX5mwf8P1tJlZGQAgC7SgwAJrGaLyWSC261WXB5/qig8Euf2SIxFGcDiAVSErFSzbuAFViRtBEBMxPqnJmLbrBYwxygjanwUSLVAPY6rueLTiCo1V1oTPvO+Vr4apVGocvoc7t5xHwE/KhAAYlraZaMAeUHJG5jyx/BW+2FrbYLrj9r7YvJYECqemZ8hqXMCyo9W4zvxBPbsD2zr2DUGB/bUntvj9sPjZUjLcKC4UP5sVFZ68PqbGzHztfW49Z/n4C9Xdsb5558vbd+9ezcKCwsBBMTX6tWrAQSirl26dEGrVq0U13420JsY0bvA0uu1AbUCK1SQ6GEewvfffx8ejwdxcXGw2WxITExEbm4ugMDvQBCbzSYZkJrNZjIaJZo2oT9G4SNYBgQ8sCJxblernQrnyh4qsNTsIfhohVobucDylCXgl+vvwrE1gX291copagQjX9SuPXkzXzzurfLBYBEgekJqrrhok8hN+KxICQKwJlhRU1wrXPjzKqbgcfHO6y5F7Zct0YKKkM+Bj6y7y7kJm48rj4FY+fWW7a9UjGisNLsxp7IIx0Pq2fw+5c/H8SInWqRZ0CLNihOnnOJbpNshxgFbtx4HANx/z1JM+/cqXHpZe/zlrx1x3gWtkZ2dLU2XUV5ejq1bt8Ln84Exhry8POTl5QEA4uLi0KtXL4puRYjeBZZeIh1qBOuvQj+/aK7BCj6LkydPhterZrsDXHfddZLJaFBgORwO+Hw+LFu2DPHxyjKEpgwJrGZK+BqsYKG72heAr69SS9upRZ74l6GadUP9fK+qDo7A6of+imNrymUtrIkWOItCoi9qRe1cgI4vJledjzBRLo74aJPIpwTVRhrGmVBTXLvMR9d4+MmXmQjEtrKj6khtdIivseJ9vfj5BZkIxLW2ozI/ZOJrN1eX5mVo0S0eJ7YF7q3YzYi3th0BDPJzHdpfjr4DW2LzumOy9SeKPbDaDejUzYaKah+OO50oPSC/lsoKD76Yn4cv5udh4KB0tGkTh+EjszBseBbi4+Nw0UUXSW23bt2KkpJAarqyslKKbhkMBvTo0QOpqakg1GGM6TaN1hxShGrzEEZrBCsoFF9//XWUlpbC6XSiqqoKlZWVqKmpgdPpRHl5Oaqrq+F0OuF0OlFaWoqioiKUlpZGpSVH9PWYaBDC2zQAAbPRSJzbGcDioBWdUoontdQkL97CeGMxEw5/dz0W3dQZqb2Vf5nz3lG8xQITAVuyRVb7pIhyhUkjhoojrQmffU6VlCBfxM6dV1HEXqSscbMnW2QCi3F3lhdlnkqfwqrClmZGZX5tG1ZsgGDyg4VctjnGBAhASTeGj7cGRv6de14a1q8ulB1/97YTyO6RjLydJ2Xr3TUizI4YeL2VaJ3sQFWlB2p/tA4clIHNm45h3doifPXlPlgsBpw7KAMjRmRh+MgsdOiYhF69ekkv0uPHj2Pnzp0QRRGiKGL79u3SsZKTk9G7d+/TjtjopbA2FL1HsJqjwIrWCFaQSZMmabYJjqD0+Xzw+XxwuVxwOBx/Qu8aFhJYzYhIUoRAIIIlhs4aHLJFSQzkAktNmMlz55FYLjCVAnrmScLaJ+7BzveSAIQxCeXqmtSiUZZ4eXE5n9VUSyPy4oh/GatP+MylBK11pzP4Y/hcfthaWGXF9IoaK5c8cqYmyhwtbfBU1I7mrCiXT6LtrfYjMTsOZXm166tLarC7gxu/bC2T1u3YchxJKTaUhlgxuFx+/HG4Ep26JWH/7lJp/TkXpGFF7hEpZRkbZ8E5vRNRWenCvr0VYAzo0TMO69bKBZvHI2LViqNYteIoFnyRB0EQMOS8DFw8IguDh2QiJSUFw4YNAxAYibh9+3ZUVASev5MnT2Lp0qWB+2Qy4Zxzzmn2Jqd6F1h6vTZAXWDpocg9EgRBgMlkkqJW0XrNJLCaKXWlCANWDXtU1oerrwpF21hUvXaL/0tUXiTtq+qOVfeNxf6vasWPaj0V52Hldao5tcvFHG+p4C73QjACLOT21NfuAFBJCXJpRYVr+nHlvYtJkwssPnLGR6x8Lj/sLayyYnbeUsJXrEzj2pMt0sRIlhQT/q/iGMq51GmN04eefVOxfpVcFFVXeXH4QDnOPT8DO7YUo905SfhttVygV1V6sHFD4Ga0THegW/cUHD9eBatVgNutfK7OHZiBrVuOweMRsWtnCT54bwdiY804/4JWGDa8DUaMbIv0jFj069dPimIUFBRg79690vDvTZs2ScdLT09H9+7dFefRO3oXWM2hBiuUaJ2HsLlCAquZEZytvK4UYcCqITLndr7wXX1kIS+e1AQW/xIIibjsG4VvR16A1F4JAE5I610q1gcGMzd9jIrwUdQtcSPtwAK1XK6SkDQi56LO7+OpVBFl/GTMfEpQxYldkVbkfLz8bq7GSi2N2MIiE1h8jZm/HIjNcqAqpA4raFpqybLg05PHcLTIg+69W4B/DjasLkS/QS2xaa287srrEbF7RwnanpMI0cBgd5hQoyJuU1rYkZhow7IlAQFmtRnRu08KzGbg4MFylJxwo1t3B9avK1TsW1XlxS8LD+FIfgWef24dWrWOxcUj2uDi4VkYcG4G0tPTkZmZCQBwuVzYsmWLNHdbUVERiooCueO6TE71Jkb0LrCaY4ow+IwTTR8SWM0Uk8kUNkUIJJ5ybrcBQugLXK3wnB86G4F4EvwAswNCaKqQ973yASwWv395LZZO6qDWAqJHhDnOBG9liFM7P4pOVYRx1g0qRqKWeLNcYHGX4OPFg4oo4wWWIhVZqTwGP7WNgRN2/PWopREt8fII3fFDJeCJybDKBFbZ3iqguwlv7jmK6lPicddWZX0VY8DWDcXoc24atqyvDc+lt4mB0+jDmrWBeq34eAvOGZyJyko3du0MnL9d+3i4XX7k7ak9ntvlx9YtgeNYLAZceFFreDw+dOpswoH9FYrPc8DAdGzbUgyPR0R5eeDYb76+BUlJVlx4UWvkXNYO55/fGiktHBg4cKD0Aj506BAOHjwIxphkchqkbdu26Nixo+Ie6QE9p9H0LrDUInR6qMFqTpDAaqYEI1hqf+HWmo3GQp7yUys8VzMW5UcWqqUWYwFZLZY8msP8LbDm4Vux64PaHxPmU6a2rIkWucDii9r9DNZE+UTM/PtGLdVo4ecj1BJHCLjGhwosZRG7vP/VKtEnW7JFJrAU+xRrpxF5UeYtZBBiABaifXlH+7LOIlZ6KyRxJaHybvb7GbZvOo4B56Vj59YTyGwfh/0FpSgvq+1DRYUHa9cExFZqqgPn9ElFeZkbW7ccUx4QQGKiFZmt4rDitz+kdQmJVnTunASfz4cDB8qQlWXDhnVFqvuXlrqxb18Zlk9dicpKD/r2S8Ow4W0wfEQWep2ThqysLGkCWZfLhU2bNsHlCtzLw4cP4/DhwwCAPXv2YMCAAbqxgdBrBIsxpmvxCOi3yL05QQKrmRFMEZpMJulHSlnHEJwuJwahKTn14nS1kYWxkBuCRjIpdK1gqS7pgv+NvQ7+mmSEpqgUqTwA1jiTLInFO6gDgDVBLrB4vac6H6GGN5ZHLfXI1XbxKUG/R35iT4UXlgS5izyfvuRHNHorfbAmmeEurd2HrylTS3mmZieieFOZtKri94DaMpgF7G/vwXdbTiItwwGTWYAvRHzl7TiJc8/PUNRd+f0MG1YXYcCwdFT7fHAfDBcNBTp2SsTypUfg84mnit2TYTAI2LfvJMpK3WjdJhYCBOzaeUK2X3mZGxvWF8FsFtC3XzrKy90YNDgdRUVVOHxInrrs07cFdu0qhedUCnXjhmPYuOEYZr6wAS1bOnDFlR3Rv39LXDSsDeLjbTjvvPOkfffs2SPNkejxeGQmp506dUKbNm3CXltTR88CC9CP47caerNpaI6QwGqmBL+4al/i2ggW/1e8Wn2VGrzAUkst8scOiJyj64fhf38dDtFlQOo5XMG6in0CL0gUqTuoCBAuKuR3izDFGOGrrhWCfBqRr33yufyKaWrMVvk+fBE7PzkzAMS0tMkEFuNCRs5jyqihI80mE1h88fyJvFJ+FwhmZaoxrrsDv5QXY93OgNgqLnRiwJB0bMiVR4nWrypUiiyBodf5aVj0WyDyk5hkRZ8+LVFSUoN9ewPnFwRg8JBM5K4ukHYLFLsHjm8wCBh6cRswEfjjD/nIxiDx8Ra0yYpXjDZMTXOgffsE1Lg8MBr82LrlhCLKGCQh0YavF+zD++9sh9lswLkD0wPRrZFt0aVLMrp06YKuXbti7dq1aNWqFQ4ePAiv1wvGGPbt24d9+/YBCIxkOuecc6IquqVXgRWcp0/PKUKKYEU/JLCaKcEfJp/Pp5iCQDgVwVI6t6u9BNWMRfnolDJCJMAiL45nXuz79Db8dndbaZ3RJn883SqpPANXwK3WRsuMEwBsCWZUhQgsrXkAA/tYUO0MMR/l+sI4d3dnkTICyE80zffNVeKGYAFYyC20xvOjIOXn8VcxmDIE+Apr1zsL5ee2tDLjV+E41h2S18wdOlAOi9UADxcFW7+qEAOGpGP39hL4fCKyzknAitW16byyUjfW5AaEVOs2cWjbLh4WiwFLF6vZfQToPyAda1YXwH1KvKalOdC+QyI8Hj/27ClBUqINZrMBO3ecUOx7vNiJkyU1GHBuBjZvKkKPni3gcBhxJL8ChSHX2q17Ag4eLIfrlF2H1yti9aoCrF5VgOnPrEXvvqno378lLriwFewxflitVlx44YXS/tu3b8fx4wEH+qqqKpnJadeuXZGenh72+poCehdYery2IH6/X2Gu2VxsGvQCCaxmRvAHKegzoj6SMJgi5B4PwatS+K5mLMoLM7XUYu2xmS8d6x67DjvekwszPjLjLlURapxtgVq6jxc+qv5ZcWbI6s0U3lhqkTH5/eH7wqfqvNV+2FpY4DoRMsEz1zfedgEI2Ca4C2vPz0fX1K45rX0KCgprhUllfo1k32DsYsY7BwvhPgYkt7Dh5Ina6z5RXIP+g9OxcY2y1mlDbhHadUlAi3YO/PZbvmK7dA01PhQfc2Lf3lK0aGFHx04B0bR7d4kkdIac3wq5q47K9isudqK4OBAl7dGzBaxWIyxWI3x+EUf/kKcEY2JM6NgpWarz2rG99lpbt4lDq9axMBkZ1q8/Bo+KDQQAtO+QgMKCany4eQc+fH8HLBYBgwYX4ZKcDhg+MgtZWQno0aOH9MdIaWkptm3bBr/fD1EUsWvXLuzatQsAkJSUhD59+jS5F77eBVZzi2CRTUN0QQKrGRPOqkGQBJZafUMc5IXvasaiVtmSeu1W4NHzlPXF9zl/QWW+FerRsFpEH1PULPGGn36XMt3Hv19UrRscvM8V742lvE6zg//6aJuPOlJtMoHFR7mqVaJcpngD3CEZMn6fsv2VEOwAC9nVXansb1w7O0pbevHetj/gP3V5Pfum4uQJuZjauKYI556XoXBtb90hDkXV1diyqBgpLezokp2MP/IrcORIbWSzQ8dEVFd5pDThiRM1OHEi0DGrzYi+/VoiNdWObduOK/oXpF//lti1swQuV+39y2obj1atYlFZ6cXJk07YbGZs21qsuv/RPyrRpk08Vq08CofDhB79UmAwMhz6vRwlJYGUa4cODhw7Vo3qkM/I42FY8VshVvxWiJkvrMc5fVLRtWsKho9og3MHZSAhIQFDhw4N3F+3Gzt37kRZWRmAgPgKNTnt1asXkpKSwl7jn4WeBZbBYNDltQWhGqzohwRWMya8m3uCyrogvLFoJCML1Ty1BJzc8ld8d2l/+N0GAKJiShdeSACALVEusPjRcIE2FlRVh6iNCKwbeINSfqJl0csUlhB89EnkbqXaKEFLnDy9xxex+10i7Gk2+byHFvlLhBduTASsmQa4D9SKwvID1RBMkKa/EYwCdoon8ekWubDZtvE4WrS048QxubBbv7oQ/YekY8/2ElRXedG1bwq2HziO6lOTWJecqEHuiUAEqkt2MlJS7BAZw45tx1FdrT6Rq9VihMfjx/9+OQQAaNc+ARkZMSgvd2PP7hKIIjDkvFZYk3tUUU+Vf7gC+Ycr0LFjIixmExITrRg4OAMH9peh5ERt3202I7r3aIHc1YG+OZ0+bN5UO3KxQ8dEtG8fhz/+qJQ8sngyM2NhMhmwYvlRrFh+FO+9sw1xcWZccFFrDLs4ULvVsmUM+vTpI0VQioqKsGfPHsnkdPPmzdLx0tLS0LNnT9VznW30LrD0THN2ctcLJLCaMeFShALsALNA3V5BXuAbkbGo4AKYKeBtBQDMhv2fn49ld7aQNbMmWmQCy+dW9s3MCRReCAXacOacXt4CQmndwKcjVSd8TjDLBJbCfNQr38db5VPMe8gbodYcVwpUe6p8ih2BL3xXs2pIcMAdImR9Tj9SusejZFcFTLFGrEmpxKp1lWjbIR6Hf6+d2sjj9iOzdRxOHq+ByAUQN+YWIbWlA70vSMOvSw/CqyJmAWBv3kkMHpKJDesK0bpNHHr3TsPJkzXIyzspCaXMVgHRElpPdehgOQ4dDEwonZRkRb8B6agodyMhwYqyMuV9OadPGg7sL0V1lReHDgX2EwSgc5cktGjhQGWlG36fiE0b1a0gACA9PQaLFwXqwmJjTchsZYHdbsfvv5ejssKHzFYWVFe5UF4uF7GVlV78/ONBLF2cj88+3QOfT8TFw9vg4uFt0G9ABtLS0qR6LJfLha1bt6K6+tTggeJiLFmyBABgNpvRr1+/Py0KodfJnvVu0QAoBZbf74fL5SKBFUWQwGpmRDofYWDC50jqq9SMRdWIBVAG5m2FZbffAOfRtgDkEwTz0Z3QNF8Qk42rp1IZWWi2cwJLRYRpWTeozkcYa0ZoPZnSfFR5HnuaVSaw+IhbzXEXDBYBYoiFg4Wr7RI5ewdnsRumFgJ8J2rXe0uU6VVLohmWdDO+9Z7A3v0BUZaQZIN87khg28Zi9BvcEpvWyIWJwQCkdYrBT//7HZmtYtG2bTz27DmJ0pMuWZuBgwJRJwA4fKgChw8Fjp+cbEPHTkmwWo04eLAc+Yfl5w3icJiQ1S4Bi389fOqYArp1T0Fikg3FRdU4cKAMgwZnYOOGY/BxqVvGgH17S1FT4wUgwFntxcBBGfCLDHv3lKDy1MhNo1HAgHMzsDqk7quqyoe9eT4AThgMAoYPz4LL7UPB0QqUlyujrolJVqS3jMGWzYHU5I7tJzDrtc1ITrbhomGtcfHwNhg2PAvJyQ6ce+65krDJz8/HgQMHwBiD1+vF2rVrpWO2bt0aXbp0Ub0vDQFFsKIXXmAFBTulCKMHEljNmLrmIwzUYamlelTmFWTgDCnVaqkccJd0xv9dMgaVh0xocY6yDe98rlb3FEmBt5GzS+DTcIDKfIRcOlJtGh6zvW4bBucxZWTJGi8foclbNTARiMvg3Ns5/yxfhcq9SpELrMrDTthSLXAdr70fJ53V+KCsCCUhUbdtG4vRoUsift9bJjvepjXH0G9wOnZvO44apx/2WBPSu8RiVW5gpGDB0SoUHK2CyWRA775psJiNyM+vQEZGjCSueE6edKEDY//P3p9HSZLn1b3gx/d93z3WjD0iIzIjIyOXyKy1qxGNJFB3SwJpGAHicHQGiTOC4QyjJ8QbbUeC4YnReyAESBq2BgEN3TR0N1RX116571vs+776Er7v84eFmbu5m0e2eAioyrj/VKWHm7uZubv9rn2/93svd25vUS5XGB7xYbPpWF9LSLotv9+EzW7g0YOqnqpcrjA1WXWff+W1NnK5EsNnfExP7UtCeREDg252ttNEo8L5Fy0dtFo1p4e9OF0G1Go1H77ffKLxwsUgH3ywLhE4n8/MqS4H2UyeubkoZrMGlbrM9HSkYdtIJMtXvjzP5kaS/8c/fY9zY35ef6Od1z/VzvCIj9bWVtrb2wGhuvXgwQMyGYGor6+vs74unGOj0cjY2Nifqw3EJ5lgfZI9sOCEYH0ScEKwXmAcl0co6LDiCo/Xt//KULHxPGPRnetv8LXP9lIpCdsXFDyhNHXtMyWSU79Y5OIFYZdqOEj9NJ9iKHRdJaxcZ1BazpfRWTUUkjXeWPrnCOFjhQadVn1LUKm9Z3Dr4Rj39tx+seEYKTcumo5Oi0SwikMafvHBKqcGnBw8lfti6Q0aNBoVpTpSef/mNoGwhcGzVpb3Dnmg4LpeLJZ59GCXQMCMw2mkWKxw+UqYleVDtjblVZ8rV1u4cb2qp3r6pKr/am2z0dvrJpMpcO9uY+4gCNE5Z876+eC9KjESsgv9mExaVlcOCYYsPHu2T06hSlksltneTpHPl5ibjRIMmXG5VJRKalaWU+SOpjyVJhr39tLs7QmfycCgB5NJi04Hel2CzU15W1yvV3N62MftW8KwwN07O9y9s8PP/vQdgkELr77eyme+o5NLEy3YbAYmJiakbefm5lhbE44vm83KTE5PnToluc//WfFJJlgvWgUrmUxiNBobrBtO8FcXJ5/UC4bai+1xeYQq7JRRWviULtYW5ASrpqpUMfPsP/0AC18eolKKSQ8rCc2pI0blvILwvV79XBHiZWojauqRi+WF3a7ZVNOQR9h4HgxOPYVktSXYUFnKNlaWLEEjsUSVaNS3BLMHebRmjaydqKur3NUTwkqhgrFdS3a15jzsqaknsiq1ClSwN1jmtx4J5KiswJ+nnxwwesHPo7u7DWJys0PLo4U9XC4jFy6GePxoRyIiInp6ncTjeWZn5NWcU10OQkErkWgGu90ga8fVw+0xcfv2JqlkAYtVx8gZN1qdWhKtOxwGWlqt3L0jn3CszS6cuBJmayvF2FiQw0NBKF9LGjs67OQLZWmicXsrzfbRV9po1HLuvBev18KTx8rTiABnR/3MzUZI13w/WlsFG4jDRJatzQQ2m1YmpK/F9naK5eVDfvD730SnU3PxckgQyr/RTk+vm+7ubnp7ewFhBP/BgwfkcjkqlQqLi4ssLi4CQtXi7Nmz/8PVrU8ywfokHlct6gnWiUXDxw8nBOsFxvMrWEr6KiWhs7KxaDnfxjv/8P/Kyp9YCF2Wk4hsLI9KA5Wat1eaGqwXvpeV4nIc8mDm+gpQpUyD2Lw+xkZRy2WRa67qoeTLZXAe3xIEsIRMxBeqJKye5KR3FSYzzY3VMke3hfhC9TNKbKZ50pnh7UdVrdPcVJThUR9P66YHH97ZZexykMf3dqRonNMXvdx9uk0uW5Im82w2PaPnvKRSBSaf7XF2NMDM9IGMcIhYWoxzsJ+hvcPB3GyUCxdDlMsVZmeqWiiAS5fD3L2zJZGhVLIgCdNVKrh4KYTZrGNjQ9ndXaWCS5dbpElBUShvs+npG3CjVqkoFkosLsaJx5WmXEGjgVIR3npzCRDIYTBoJR7PShONFy+FuX9vu0H3tb6eYH09QSBoweezYbHo8QfsrCzF2d+Xv9+FSwFu3RBYXT5f5qMPNvjogw3+7b+6SWennc/+7V5Gz/m4crUVk8nI1atXpW0nJyfZ3hYIZiqVkpmc9vf3EwqFFI+tFp9UIvJJr2CVy2UqlUpDi/CkPfjxwgnBeoGh0WjI55UrP4IGK6mgr1KaOjTKXdlJk929zB++8RlSG8JXrL5tRwWMLsH4UnplhRzBeuF7QWG6T1cXzKxUWdLbtTKCVS8TU9Jy6czHO7OntrMyKwRorIwptQSNTp2s+Vqq299sJN/g5VVW4Hlmv1EiWHqvjj/M7lLyGBqel0oVmrYE2zrtmC1a9C4NH91YbyB7iUQ1tPnlV1vJZUv0D3iYUtBChcNWdHqN1Aq8c1uuhbLZ9ZhMWt59u7lJaV+/m/m5KJEjIb3Xa6Kr20mxWGZm+oBSucLQkFdR95VI5Ll3Z5vxC0GmpiK0d9jp7rGyvZ1gc6P6+Xq8Jlwuo8xHa2kxztKi8Kk4HAYuXQ4Ri+Ww2fUyUb+Irm4niUTV70t6vMuJz28icpBEb1Bx51bziUaH08Av/+IjMpkiZrOWiathyQairc3OwMAAQ0NDAMTjcR49ekSxWKRcLjM1NcXU1BQAdrud4eFhxerWJ7mC9UkmWOKNb32L8KSC9fHCCcF6wVDfIhTFtg3Pw95EX6UkfK+p2lRU7N58hT/+m6ehUnNhVyh8GZw6GcFSmsKrF74rVZrqg5mVDD719aL2uqpEIVVCbVBRrnH9rtdc1RPASqmCtc1Mcq2qyakXviu1BOv3V8m93XnKyv7TKg0rbFUa9k98TX2nnt/Y3WI7XqTdoEOlklfFluZiTVuCWxsJesbdJDJ5hk57FWNpNBoVFy6G+PD9ajSO0ajl7Dk/RqOWxfkobo+Jvb00m5uN03fFYpmF+Sinh33cvL5Ka6uNtnY7yUSe6el9yf5h7HygQU9Va1TqD5jp7nZRqVRobbOyvtb4XrU+WrUtTFG0rtao2NlOMT/XmNcIwlTkwKBH8upSq1X0Dwg+X7u7KebnYpwe9rK6ckhCwcx1cTHGzk6Srm4XK8txzo8HKZeLzM/HSNRUYs+Ounj2dJ/iUcxROl3k7bdWefutVX7qn1/j8uUg5y8EefnVVi5cDGGz2XjllVek7R8+fEgkIhzf4eGhVN3SaDQMDQ3h8/mAE4L1cYXoVH9Swfp444RgvcA4vkXoPPpvvb5KqeVy9DWqWHn0H/4hd/99QGj/1fCc+oBlaKw8KbXTGoTvCmREXedHlVdwaq8XtSv5Zxmdelm4cr03lhK5M3n0MoKVTzQ+p6ElWK6vhDWS3GRR3h6r5Cu4hm1EnlYfj84lYEjLz0+ukzkiKatLh5y7FOBBXeVEbAk+uLUtkSybU4+9zcDNW9UwZsEx3cbKSpzNjSRWq46ubpeUMygimy1Kk3/nLwRJJvL093vY3083VHXcHiM+n1kKeRZbbICkv/J4TTy4t6soVgdoa7NRLlektqD4WGubnUQiz+zMPmPnQ7K/12JvL43PZ2JjM0kmXWDkjA+rVT7RaDRpGBjwShU7ECYaZ2omB19+pZVCoUxvn4vpqcZWqVgde3LkVF8bbN0/4MbpNKBSl7h1o5HsimjvsLO8nODmzW3+088/xO7Q89LLLXzqjXZef6MDn8/MmTNnJIKxs7PD1NQU5XKZUqnEkydPlF/4E4RPOsEqFosNTvXpdPqEYH3McEKwXmAc54Olwn70f3LndmVjURXlXCdvfe/fZ/0d4QJgdMvdyJWqU/V2Ckrkqd5sqpAsNlRyGqJwlKwb6kXtCh5bertORrDqq26KMTZ1FTYl41CDs67NWffeSu7tpUTj6lvUyInjfmeJ64WkRK5E7Gyk0GpVUnVExP2b2/QOushlS+RLJZKqAs+eyStWomM6wPnxAHa7QdI4KUHJed3rNdHV46SYL5NI5kmlCjKSUotMuoBer+GtN5dRqaqu8Ht7aanKNDTkYWMzSbzOfHTtiBwZTRrOnA2Qz5e4cDHIzMw+h3VGoWPjQZ492ZOCpZ/URPW0tdno7HKiUav46MPmVg4TV8J89GG1jarXq2VErUKFShnF6phI1CYmwty4vlu1gcjmmZ+LkT76fXR0molGMhzWDDocxvN8/atLfP2rSxgMaj716Q76+ly8/kb7UfSQj0AgAAgRPo8ePSKZrBL6mzdvAoLJ6cjICE6ns+kxflzwSSdYSjYUJy3Cjx9OCNYLhvoW4fEi92/NWDSx0soffcd3ktmpXhAMDi2ZmuGsQrKxqlRfeSqmS2hMakqZarWrYWqQxkpTfUWoXKw0TB/WTygqGonW5xHWaZbyiSIGl45ctHbbOhuGvSwao1qmq9Ia6lqCB40kzBquI6TbFXR2LYVaZ/vY0WvqYLYjy9cfxQmGzQ1kanM9ydilAPcV9D9zU1H6Rz3Y7HoSy80nL/v63SwvH0pi99ZWG63tNhKHeaanBI+q8QtBxYqR2NY7PewlGskSCltpb7ezunrI5kZ14TeZtfT3e6TqmFJb79w5P9FolkJe+XvqcgvVsdppQ5UK+vpceLxm9vbS+P1mbt7YpFxWLhmVKxWWFmOsryWwWHWc6Xej1apZWKjG8ExcCXPjuryKl8+XJaLW2+dCrVLh9phwe0xMT+3LnO91OhVnRwPcODrWWhsInU7N8LAXj8/A8lJMRq5qYbXq6Ohw8CdfW+JPvrbE//7/vY/Ha+K114UIn1dfb8flMnHx4kXhuMpl3nvvPVQqlWRyev/+fen1QqEQg4ODiu/1Vx2fdILVLIfwhGB9vHBCsF5gfGsVLH3dX2p0LxU1m+9+Dw//t5fJ7MgrFLo6N3KZwPwYmNwGkhvVSlG9PxWAwSEnWCWlycK66cN6EqZsUFqvuWpc1M0Bo4xgFTN1568itAQPl6pEtLEl2CiOT+XleqJKCZzdFvYeVKtHmbU8xhY93yhHuD8lvP72Zpre02bmnskri/dv7XB+Isi9G3Kbg5EJHzfvb1IolFGrVYye86PRqHn6ZFeyY1AKW65t64VCFvoGPKSTeRwOg+Kk3oWLIR493CGfL0saKoCOTgfhsIVMpkAmU+Lhg+Yi8J4+F2+9tUylAgaDhjNnfZjNOomotbXZGkgZHBG12SiquSiXJ8LMzUYZvxikWCg3tPX6+tzsH6SJHAjktn6icXDQQ2ubTXKnV8KZUT8Lc1FZBqPFomN4xI1er2ZzI4nTZWywnBBRKJQxmXVc+3CLYrFMS4uV1jYbiUSWudkYhUIFm02Dw6ltqDge7Gf4gy/O8QdfnGPiSohiqcLrR0L5/gEhbPrq1avo9foGk9OtrS22toRBBIPBwNjYGCZT/UTwX028iATrpIL18cMJwXoBId7RfisVrIaviKoIFRNUdNz/9/+QB//Bh29UwWm8TiCeTxQbImHqheYgTPtRUxQpKAnf6ypNDSSHxszCej8qpSpXfUUtp+CtVe/MrkQcjU49hzWVvvpjEMTxJpJrVeJRiDQeZ73IXhfW8ZY1wv0n8ipiZLeEVgfFusLHvRvbnBn3s76SILKfZuSqnw+vV4Xq5XJFin2xWHWMnPXjdBi4cX1DRq5qEQxZMBi1vP+uMAmo0RzF2jiNbG4mWFk+VDTuFLGyHEelqpDNlsiki4xfCKJSqZidiUhETYjfCcteI5cr8fhRta03cbUFjUZFJJJFs5Wg/mtsMKgZHvFLVSexWlTb1quU4fHjXUXLCRBIkkar5q1vLAOCvqq720mxJMTwJJMFLlwM8eB+Y4RPKlXgwf0dPF4TbpeRTKbIxJUWotEMM9MRWUt14kqYmzc2pcc2NpJsHFX6TCYtlyaCQFmqHCph4krVtuLOrW3+Pz99h2DIzNBpPanEIq+93oHFKjc5XVxcZHl5+ej85rhx4wYgXB86Ojro6upq+n5/2XgRCdaJBuvjhxOC9QLjOJG7ShK5N17EisnTfOP/8u1sXRPudpXE3/U+UwBGt4H0dk0bTMFOQWv6FoTvhkbyVg+dsZ6EKeURyqtc9UhuZxsMSuuF76ntbIPLeqMuq3HM3+w1yAnWTgWDW0cuUj3e9FZN5l+fjv+8sIXJqUerU0neVQAHeznGJ4LcvdFYIXl8dxenR8+Fbwtyra7FVYtctohGreabb61gMGoYPefHYNCwMB+TKlB9fW4OIhm2t6pVtVKpGmuj06l46eUWisUKZ876mJrcbwiIHh7xsrJcncATqzoajYqh0x5cLiNarZr332uuhRo7H+D+vW1JEG82q+npc2HQ65ibjVKpQEurVRKY10Js6126HOLunW3CLTbOtlo5PMwzM30gtVp9PhN2h0HmPn+wn5Fahjqdmk9/WwepVIGWFisrCjmLrW1WKmWYO9Jkidosl8tIT6+LcqWCyaTlow/WG7YVEQ5bmZ48kD6DU10OAgEzBwdpFubjVCrQ129WbNUKxqpptjYe8JP/yzWGTnt4/VPtfOqNdrq6XXR2dkokKpvNcv/+fbLZLJVKheXlZYl8mUwmzp079+ca4fN/FuVyGZ1O9/wnfkxRKpUaCGQqlcLj8fwl7dEJ/iw4IVgvMI5zcgf7kc1CXd7e2qu89X3fyf6j6uKfU5jaU7RlsOtkBEvRcqFO+K5k5lnvqK44WVg3faho3WCTf/0btFz5Mnqvhvx+jR9VoTFSxxI2ktqsHle9biy9k0WlU1GpIRtlTR25rID9lIW9SEx6KLGaxugzEPEX+G+P1ymVIbGdUSRTd29sc+FqiDvX5O77do+Osq3IW99cxWzRMHrOTSRSYHWlOo1ot+tp73BI03O5bEmqbInC844OG+vrSYlg1MNu19PWbuejD6sLvcVy5NB+pGfq7nby4P4OhUIjsS6VKuzspCkcOa+HwkK4dDpdYHrqgPxRq3jiSgu3bsr1VOl0mccPBZLX0molFLKi02no6nayuBBreK9aPdXa6iFrqwI5str09Pe7MZq07O2mG1qPIlQqGB8P8s2jcGqAlhZBZ5Y62t/2DgeRSEZqPdYiGs1y/94258eD3Li2wdBpLw6Hge3tpOTFBTA07GWtzg6i1q/L6zMxPOwlHs/icBSIK/wOR8/5mZ6KkM0W+fD9DT58f4N//f++wakuB69/qo03vq2Di5dCGI16rly5Im03NTUltQ8zmYwswqe3t5fW1lbFc/MXhRexgnWiwfr44YRgvYAQW4QajYZKpaJ4sVKhQbBoOFrIKhrWv/H3efPvD+AbNQI1BCvaGEVTUlhE63VZSmHO9YakhVSpQTRez96UxPH1r6OkuaqvNClVubROOcHKKQiQTR6DjGDVT0xWymBrMZGosXOIrze6lKvr9lmlVbHYnuL3bspbQ0vzcQxGTYOlwZ1rW4xfCfHkvmB30N5jZyeVZmdVIEXpVImHDwTSEAob8PlMZLNlcll5TqBs3yvg8Zh4+5urlMsVAgEzp7qcZDJFpqf2yeXKksFovYdWKlXVM01cbeFgP8P4hRB7e4KfVC3qY222NpNStqHZrGV4xIvHa+bBvZ2mYvWeXifxWF6mdQoELZw65SCbLTI7c8DImUCDWF1EMpEnnS4wPx/lMJ4TJhq9JvZ2qxONer2akbN+Sawuoratd348CIDHY2RRHWNvT05KjSYN/QMeKZR6skZXJe6v3qDh0YMdRa8tAJtNh99v4b13hUqfSIStVjXb24dsbuTp6zfx5PFuQ/sUBKIWjWT54P11tjZTXHlJMDl949MdhFts9Pf3SwL4eDzO48ePKRQKVCoVZmdnmZ2dPdoPGyMjI3/h1a0XkWCdROV8/HBCsF5giD/gYrGIXl8vZgewAwUqZRd3/tcf4MkvCuXp+hZduVhpiKJR0kVp9ArVqYYQ48a9MLr0pGraZeVi4wJrdOpJZWqqBXVPUQqFVtftT2a/UaytNdU5s+80ViTq/byUXsfkMcgIVmGngt6pJR+rnqfkenUh1to0XHMeMr9UaJgSPNjLKFarAO5e3yLcaqWt185Hd9dlwutabG3mMBl17O1nMZlUjJyxk0xWWFqsEj+NRsX4Rbm31M5Omp0d4ThMJi2feqOVQrHM9KSyPkirVTF2PtigyfL7BaKWyxcpl8osLx1yeKhMJkqlMiqVWrJyaGsz4XBqyWY1ElE7c9bHwnys4Xh3tlPsbKcwmbUMDfnI5YpcuhxmeSkmHYeIsbEjo9MjK4fZmQjMCH/z+cz09bswGLXcbOK1BYK4/+EDeZWuu8dJwG/hIJJhZydFMGCRPMTqsbOdorPTzrUP19Hq1Jwd9WM0aVlbOZRMXD1eE06nQUbM6sX+r7zWRjZT4PSwWWYDIcLvN2Ey66Xz99abK7z15go/yUcMDrmFVuKn2xg7H8Rms/Hyyy9L2z569IiDA+HzTiQSsgifoaEh/H5/0/Pz54UXkWAlk8kTDdbHDCcE6wWG+ANursNykD+08qd/90fYvVuNYKlv0YHg9VRLsJR0UfW6rEoZjF492f3qdkqVL71dJyNY9dEyIETqyJ5T/zoKodD1Va7UdmMrr7ESVmgQx9c/J72TbchZrBfmUwFnt43de1XPpNRWFmvYSL5S4g+yeywsCkRNaRrwzrUtxq+GuKtAsrwdZt76cJlTXQ7cbqGKka2rdo1fDPLkkeALlTiE3R2BmNgdGlpaTKhUGrRaHbduNNdtDQ55uH5tk2y2iEoFPb0ufD6zZDYqtB7tUqWmFru7aXZ304xfDDIzF6Or24nRpGV5UU58nE4DoXBVT1WpwNpahrUjiZbXa2LsfIDIQVbR0gMEo1OPx9SgyerqchIImolGczgcOu7cbl4dq1QqbG+nWJiPoderOXPGh9mik1lP1IvVRSzMx1iYjxEImAmHrVgsesYvBJmdiTSQylqxeqlUDbYGYQLzVJeDfK7IrZtKQexHr3G1hQ9qNGw6nRBVZLFqWV87pFgsUigU2F1WbvdOTUZwOAz84i88xOEw8Mprgg3E62+04/WaGRkZkcjN/v4+T58+pVwuUy6Xefr0afW8u92cPXv2f4qT/ItIsE5ahB8/nBCsFxDiBU+lUh1r1bB/7zO8/X9vJTEtvxArrWP6elsGBV1UvcYJBKF5LcFSatM1OL4r6Km0lrp2n4IjuN4uD4Wmbn8qpQq2FjOJ1eoCXzv1KMISNJE/rFZ66t+rXKxgbTXJKlJ7KwoVHoX1Id8O//XBFpFk9TVXFw/RG9Tk6+wo7l7b4sKVIHeuV4Xi/Zc8fHBDWFwX5mMsEMNi1XHxkp9stsjks30uXApz8/qG4ud4GC9h0BfRG0rs7R7S3WPCbNazsZGT6YnqDUYrFUHELbbSBgbdeH1mUskCJrOWjMKkXi0hqSUS3T1O/H4LmWyByEFGEtErobffLcXaSMTHqmN1RSA+rW1WqKga3OVBiLVZXIxx5UoLU1MHnB8PCi2wOuLT3m6nUCixMB8DBKH84xqj0vZ2GwODHjY2kmg0jQavIJCjbKbA5LPqsWi1akl/tbWVJBSyNHWiB2G68tmTffb20kKwdb8bjUbFzPQ+8XjhKAQ73FAtLBTKUvu2p9eJSmXA7TaSTAo2EPma77hKJfib3TwKqI7Hc/zxVxb4468soFarOHPWx3f+rS4uXAxydjSA2+3mtddeA4RJxCdPnnB4KGjaIpEI77777tGxahkZGcHlcjU9vv8RvAgEq17Ef0KwPn44IVgvOI6zanj4n0ZJrDb6FNULvUEhDzBRbNBO1VslAOit9ROBCoakdS7silE4dZYGSgJ6fR1RU3JzN3r0MoJViCtNH8ovfEr6LpPHICNYha0KajOUa7pStX8HKAxp+N3FbaJ1+7W3k27aErxzfZuhs17S6QIVK1y/2bhAp5IFbt/aQqdTcfFSmGKxzLlzASYVApt7el3EYzk21oUdXZjPABlUKgiH9Xi8BqxW07FEoLfPxf5ehukpoWVlMGo4M+rHbNKytBRnbzfFhUuNxp0iFuZjaNRq9g/SUIFzYz4SiSSbG3mp1aXRqASj0xoyUU98Jq6E0WjVRA4yaLYaw641GhXnx4NcF+0NGsKpDRTyJRYWosSiShFRwmsEQ1aJ5Nlsenr73Wg1Kubno0QOsgwMutnaSjU40ReLZSaf7aPVqjg3FmR5+ZDLE2GZvk3E4JCHjfWERPwSibxUkVOpoH/ARXu7g+Xl5q77Q6c9rK0mZLouo1HL6Dk3Op2K1dUYTpeOO7eV/brK5Qr5fImf+9l7pFIFfH4Tr77WxuufEkxOHQ4j4+Pj0vO3traYmZmhXC5TLBZ58OCB9LdgMCgFWf9Z8CIQrHpd20kW4ccPJwTrBcdxVg3WoJFcvIDJWh8y3Ehe6j2kQGjJycTfCtUpjaFO+B5Tcnx/vmC9vm2pSMLqRO1pBa2Urt4mYr/YaNVQR/hqW5PS69SROcrgHXCyez9Wff+tLNYWE6mtDFv9ZX7nkUBmlVzY798UPK0e323U7uzvp6lYwWU00nnKzvJSo2WAw2Ggtc3G9RpCYjRqOTcWQK9XszAfo63dzvTUARkF/VylArFYGYdTw43ruzgcGsItRipoWV5MkD0i0ufGhKm12tfIZUs8PqpQmc1aLk+0UKlA/4Cb2ZlIQyVtdCzATM1+RCLC+dXp1AyP+LDb9ag1qmPtDUbHAjx8sCu9hsNhoLfPJXlu5Qsl+vrciu3LYlGo+Iye8zMzHcHtNjIw4CWdyjM9XZ1oNJm1Da+RSOS5X5M/+PqnOsjnSxQL5QaCBUeC936PRO5EYb/JpGX0nA+DQQOVCo8e7TX1JjMYNBiNumP9us6OCsdS/xrZbJGHD3YxGgXhfTye4/JEiINImoW5OOWae6mh0y4WF2JSu3lvN8Pv/94sv/97s+h0ai5PhHjtU228/EorA4NeAoEAoVDo6H2yPHz4kHRaIO7b29tsbwvnSa/Xc+7cuf8h8vAiEKyTFuHHHycE6wVEfVxOsxahOSDcQRndBpknk5K+SsmXQW/Tk6qZNlSKp6knT/nDgvCtrHkLpSgcg1NXR8bqnNrjjQL6+uDo9HamQXNVv9iX85VGq4a6FlAxU8LkM8hyCCPbMeqh0jZqUYytej7SR3jvcZUUbW2k0GjkFZdSqcLU432GR308fVit0nQNOVnejROp+XwGBj04nQampw+IRXO0tdkAGqb8stkiD+4fTfldCROJZBkdC7C7k5LaYSL8fhM2u4GpSeHxeLxEPC4Ynup0Krq6Tfj8JpYWDxUJGgh6KafLKCN5brfgCVUsVZiZ2mf4jJ+7t7caqk0gtLq2tpLkckbmZqO0t9tpabURP8wxM3UgbSN6XNW+Rjyek6YLfT4Tg0MeVCoVp045WFLIWqx9jdoJQYtFx+lhH0ajhlyuJE1JKmH8QpAPP1iTTEh9fjNdXQ7y+TLT0wfodRpCIYusPSoikyny8MEOFy4Gefhgl7Y2O8GghVgsy/T0gUR87HY9La022WvU+3W98W0dZNJFAgGzol+Xzaajrd0uvYaYPSm2IcuVEqVSkcmnMcX2Jwjt2YODLP/mXwq5hy2tVl7/lKDbunq1BYvVwOXLl6XnLy8vs7S0RKVSIZ/Pc+vWLelvbW1t9Pb2Nj2v8GISrBMn948fTgjWC47jKliWI4Klt+tlBCsbabwTV2r/6ep0UVmFypMS9A4N+YPqPlUULuoGh5xg1ZOeSllo98k0VzSK7O1tJg5Xqn07peqcrs6qQamNafYbZQQrt1oEHVDz1NpqHoDer+Or0S1uzsotG7bWk4rC9kK+zNSTfcavhHj6YJeuERf3nm432DWIjt9arZrXP9VOsVhuqmOSXNPr2nWiXUAmUySTKRCL5hpIl4hisYLHY+fWDYFshMJ6PF4jqUSZpSWBmHSespPNlhqCkCORrFQBuvpSC4eHecYvhlhcOGBvV/49a2+3UyxVrRxWVw9ZPfKwstsFMuB0G7l7S5mggbDwq1QqKf8QhOifjk4H6XSRmel9xs6HmrZAU6kCW1tJdDoN62uHgrDfb2Z/L8PcbHWKT8nNfm83zd5uWtqP1lY7KjWEW6yyjEbpNWo0aqJeDMBq1dDWbsZut5JKFXj6ZL9hWxFj40HefXtVEu+3tFhpa3eQTguZkharHrfbKNOGiRDbkJcuh7n36ICubhcut4HdnaRs2tRm0+Lzm2WvsbGe5Au/McUXfmMKg1HD3/3uPrp7nLzx6Q46Tzlpb2+ns7MTkJucAqytrbF2NMVgNBoZGxtraJe9aASrUCiQz+dPCNbHDCcE6wXHcSJ3a1C4qGnNjdoljVlNKV0tDym3/+QXwEKiiNogbzcqWS5orXKCpSh8rzMJVXKFrxe1FxQqK0aPQUawlCwW1Ma6ytduY0uwwbS0CL4zDvYeV6sjyfUM5qCB9HYO3Skdv7q9zd5GkeFzPp4+kPtQTT89oKvPyeJsTPZ4qVTh7vUtxt8IkswWlCcOjnBuzM+1j9bJ58uoVDAw4MblNrG5mWRlOY7ZrKW33y0jGyJEe4Ozo34iB1naO+x0djlYmI/JzEaNRg1Dp73cuV2t5Gxt5tnaFM67za6ht89Csahme7sxKByOgpDPBbj2kZyQtLfbaGm1E48Ljvob60nFNhsIxEetVvHNN5fr4nuEYwVBG3Zw0Gj+ubWVYmsrhUoliPczGcHKYWE+KstRBOjqdpI4zLO9JRC7WmG/2JpzOA1c/6h5+7Kjw04uX5KMXcXHwi02Dg9zzEwfcPFiWNKG1SOZLBGPVziMJ9jeTknHWm9UeuVqi6xaCHK/ro4OO6GwsGAnE/kG2wqQTzXW2kB4vCa6upyUygVi0SyLC82zGkdHA/zWb05RqcC/+l9v0NXtkKpblyfCGAxyk9O5uTmJYGWzWZnJaVdXFx0dHS8cwUqlhN/OiQbr44UTgvUCor5F2KyCJbYI6zVHcBTKnK4uPnmluByF8WyT2yC3U8gpmHvWaaWUXNjrI3WKSk7t9ZON+40VNG2dOF8piLmu8EX2II/WoqFYI0bPZxU0X/XWDICtzUzSVeLnpzbIHlX9UsnG/UolChxoM7SfsrNao6nS6dV0jbn45ruCi7jbY2TsvIftraSs1VVfQalUYHq6ukCeHvbi9ZnY38s0tCNFXJoIS+06kWiIhpZer4lYLEu5zLFtsv4BHw/v71IsltHpVJzqMmGx6NnZybG3m5Uc4O8qCKtXVxOsriYYOx9gbS1BX59bccrPbNbSW6OFqo3vAaFCdPq0h0gkK5GtehgMak4P+2SERLKeOKpQ6fVqVuuc1WsRj2WpVOCtN5dlmYdra4esrwmkpq/fzd5ummhUTvJWVg5ZWTkUSN7VFnLZEhcuhpifjxKNyJ/b1e3gMJ6XPpPaYw0ELXR22rHb9Xz4YXOS19ZmI5srych1V7eTYMBCNJZlZvqASxPNMyUP9jPodGq0WjXbW2nBBsKiZWPjUBqQABg955IRSYDFhTiLC3H+2395Slu7jbHzAS5PhHjj0x0EQ1a6u7ulFmE8HufJkyfk83kqlQoLCwssLCwAMDk5+VcuwufPC80Iltls/svapRP8GXBCsF5wfCstQtSNRMlg15GkSrD+R2wZagmWEjFT18flKArf656joO+qr7yltjIN/lT1BaBKqYKtvc6qIddYHbOGTMTmq22d6FzjHXxtyxAAFcyWo/zqYzkhWZqLM3rBz8M7ci1OPJpDpVJxdtzPo7u72F16rC0Gbt2uLliRg6xUYejqchIKW9DpNLx3FMashJ5eJ3u7aUmTJbbXVCoVM9MHHB7mZZWLWoiGltmMnVKpTKlc4fJEmHRamHwTBeDQSPIKhQpLi8JUIkB3jxG73UA8nkOlUi7GXb4S5vbNLcrlitReq0756YlGspTLFUUdk4jWVhvvviNooUQNlU4nxPcc7Gew2/W0ttkbiGKt9cTY+QBbW0K1qFgUgpdrQ6JFwbsoVhczD0W0tdvp73dxcJBlMaFchRNImZ/rNZU8tVpFb58Tra5AKgkWq5GNtURTU9a93RQdHXbe+oaQKXl21I/JpGVl5VAS0Hf3OIlGsw2VvMWFmBQt9PIrrWSyRS5cDDE3GyFWVzlsa7ORz5dYXxNahbX6vlDYSnu7DYMBbirkY4oIBC1UyvCVL8/zlS/PAx8KeYlvtPHa622MXwhhs9l46aWXpG2ePXvGzo7wOdVG+KjVavr7+yVR/ccdSgTLbDY36LJO8FcbJwTrBcdxLUKTW49Gr6asUN2oJy/5eKExb0/BzqG+OqU07deQNRhrFKzXF8e+lcnCcrGCtc1MstZRXaHyVW/VUEw0HofBJXe+L6fA1mUisVglnfHFlBTgrDGqedqS4c2bMbr7HCzMyisp25spPF5TQ9ZfLJIlFsly+bUwu8k09+83rxZFohkMRg1Tkwe0d9hpabERjWaYma5O6o2e8zM7E5GRg8PDaryMxaLlldfaKOTLtLXZWFtrjPQZOi14Pontuu0t8e5ay/CIQF70Bg0fvt+8gtLT6zzSdYmCag3hFgMatZal5RSZdKkpyROn/NrabJTKFdRqFRNXWkgkckxPHciE2PVtslSqIAn7VSoh1sZu17O21rzFdelymDu3BZInkpRas9H9/RRqteZYkhcImnn/vTUKhbJk5aBRq6QKldmspbvH1WCGWi5XmDtqE58d9XNwkGFwyEs+X2J6+kDmL6bXC1OWYiUvl5UblXZ2OujqEc77soKwHwRN3viFEB/WTGhqNCoGBj243Ua2t4VWqhJBE7G1maSz084H729iNGo5O+pGr1exvByTdHVen55yqcj6tpy4TT47YPLZAf/p/3jIq6+34rAbeP2Ndl7/VDser5nBwUFOnz7Nu+++y+DgIDMzM5RKJcrlMlNTU0xNTQHgdDo5d+7c/xST078IlMvlBoJ10h78+OGEYL3g0Gq1FArKcSoA5oCBkkIFR7ltqCe9U71gFtIKuiyjfLusQo5hA3uqCL5StfqohsnCQqXBYb2Ub9xvs8cgI1iZPQWLhXqrhoPG41CypbAGzDKCJbi1W4mQ4C1DlIfTwvsazbqGbbc3UnR02SkUyxzWVQt6z7i5/nCDRCLP6LkAlUqFJ493ZSP07e12yuVqa2x15ZDVo4kxj9dET48Lq1XHzRsbMnJVC7fHiN9nlrmAi0QtHs8yPXXA2HjVAb4egkj8gO4eF7dvbdE/4MbjMbGznWKhJnT5zKifhbmoLNYmkSgxI54fo4ozZy0kk0l8fiN7Cpq3/gE3OzspyZ9KrKSIk29qtWBD8eExVg7tHQ7W1w4l7ZEw5eckly8xfeQRpiRWh6rnViBoEawUKDJxpYV4PMvMdETWcr08EebWzarDe72Vw7mxAC6XkZWV5h5WtRE84rEaDBrOnPVjNmvZ2kpgtxuPbdfanQZuXNsgkylitwskT61SMTcXIRbNodOpOHM20GBdUSpVpMGJ/gE3+VyJ3l43+Y5GkqdSwcXL1aGJbLbYQPI6Tgnfp8cPm4vzr1xp4f13hc/uj45MTs+O+nj9jTZe/1Q75XIZh8PBq6++Km3z4MEDolFBDxeLxSSTU41Gw8jICG63u+n7/VVCpVJRrGCdCNw/fjghWC8gau/qNBoNmYxyZAYIbULF2BuFG0ODQ06wlGwZ6u8oK6VK47SfQsVM79DJCJZSdczoMcgIlmLAc50uKr2TRa1XyRzbG9qGeYFo1h7b3kLj1JVSmzJJjt8u7LGxU92XZw/36T/tZuZZRPbclcVDuvqcGE0adreERX/kio8bdzelUf+HD4QF1Os10dvnIhrNodWoWFtLEI8rt54iBxlUvW7e/ubKkbFkAINB8L4SdTwdHXah9TUt36daovbKq21kMkVGzviYmT4gUTdNKVo5PH4ktMZmal4rGLLQ2enAZNJy88ZmUysHsV33+FFtALIOn89EOi1kJY6e8zM12ejpBAJ5efpkl9PDPq59tMHAoAeXy8jWVkLmDzY45GFzIyk7Z7VTfiaThk99uoNUskAgaGFHQaDfecpOOlWUzo/431rPLaNRcyzJ8/nNHBxkpKpaIGCm85STRCLN/FyMfL6RoInI5Uo8frSLw2EgELRIrd162woQKnWPH+1KGYmHh3nu3amSvJEzPgJBC8tLsab7OjziZWkxTipVkPR+AskTKnkbawmCIeux8UoarYrHD/eJRrMSGa5USiwuxIgdSQFOj9gaBP7lcoUH93d5cH+XL/zGM0wmuHCxxBuf7uCV19qw242cO3dOev729jbT09OUy2VKpRIPHz6U/ub3+xkeHm66j3/ZKB/dOdUSrJMcwo8nTgjWC47jRO4gEKzEWqTh8YoCCdLVi8ojCrosBZ2NwSGf9itlFQhWvQu7QnXM6NJzuFRdCJObCsSxnjyVwRY2cbh8vFWD2WeUEazibgWNU0UpVuO1NJeUuder+nX8pyeraIyNFatyuaIoLl+cjWEyaxm/EiSnLvHhdeXFeX8/w/5+houXwqyvHzI45CGZLDA1uS97TZNZS3+/h5s3hAVLMJastsj6+t20tlnZ3cnw9Mme4nsJrukhPnhfnm83POLDZtOzshLHaNSSSuabWjlsb6U41eXk3XdWMZu1DA45qFSK7GwXiR5VoQJBCyajVhZiDLCzXWBnW1x8LaQzKbq6LSwvJRtCjB0OA+EWq1TJESsvIGiDOjrs6A1q7t/bIalgtwGC4H1wyMs731yRHuvqchIMWohEBQH4wGAjQRMRj+e4d3ebi5fCXL+2IU35bW0lZa25jg472WyVoIE8TNtg0PDpv9ZKMiGQPLEVWwufz4TFqpcm/EQRf62uTqdTc/PGZtOcRYtFS6lU5ptHRqWiX1fhyK8rnS4KpHbqoMESRCB5e+h0KkbO+NnZSTFxJUwikW9o1/YPuNnaTDZ1o+/rd9HWbmNxoTHWSEQobCaTybO7U2RleY7f/705dDo1Fy4GefX1Nt74dDt9/R78fj/BYPBoH3M8evSIZFJo7+7u7vLOO+8AoNPpGBkZwel0Nn3Pv2iI1+OTCtbHHycE6wXHcSJ3AEvQSOYgj06NjJwU8wrtP728bVbMlNCaNRRrFkGlypPOKicgpW/B8kHJi6p+IrCYbjQALSiQJ6PbICNYSlYNensjSfL1udi+XSWfpXwZ7xkH+4/jJE+r+G+P16mU4fywj4M9ubZmbirK6AVBvN5QMaNCNJ9jczvJ5YkwTx7vklLQil250iLd6Ys+Sna7nv4BD5VKhb29NDqdRiJU9ahUBELy0QeClYNYZUpnikxPCoJ1q1VHV7ezYRKsUChLhGzkjI9crkRXtxO3x8T01IHsmLRaFWPnq7E26XSRqUmBCAgxL27CYSvRaJaHD5rrmGqPV3zdzlNGbDYDe7t5KhUVRpOuqefX1maSjg471z7cwGjUMnY+gFanlllPCBU0W0OrrdaHauJKmFK5Qo/ZxcyRU3otRLG6eM5q9ycUstDe6UCjgfnZGLu7jdYIIsbGAnzzG1WSd6rLQTBoJX5kNhpusVIqoainEnV1E1dauHVzk74+F26PiZ06E1mny4DXK/ewqq3k6fVVo1Kv18TGeqNfl9Gooa/fI50zkTBarDrO9LvR6tQUC2VmpiOytnA9nE4jb78lDGe4PUa6u13k8wXm56KkUiX8AR2pVI7DuviqQqHM9WubXL+2yTvfXGVzM8lrr7fxqTfauXK1BbNFz8WLF6Xnr62tsbCwQLlcplAocP/+felv4XCYgYGBpvv4F4FSqYRKpZJV+9Pp9EkF62OIE4L1AuJbdXIHoYJVLlYw+PXkaiYFC0ptQ4VpQ6NHL7NzUCI42jpdVv5QQfOke/5kodLUoiUgNwBVIk/filVDdLdxEVOqCKhMKpb6CnzlYZV4Pbq7S6jFyladmeTDO7ucvxzk/q1tiZC4AybUThX37guEbGszicmk5cLFELlckWdP99HpjiwFFATgh4d57tzeEqJSimXsdgOXJ8IsL8cbKiD1+qLtrZT0HItFx4VLYfR69bGk5+KlMPfvbUstTACXy0hvn+DOvr56SCBoUYykAYHk6fUabt/eIpUsKJI8kaDVH2+xWGF5KQtkCbcY0WjL2GwauntsLC0mZBq1+uNNpQoSIRAreYGAmUKhJAUdNzve2zVGpjqdmuGjicb1tQTRaJbOU84GsbqIra0UPr9Z8s4So4oWF2Ls7Qm/E40Gwey0rtW2tBiXfK6GRwQLiGKxTCqZV5wqrCWkta1fsQ1ZKgvxPUpB2CLOjQVkRqWCJs8qVagMBg0dnU4eP2r8jqSSwjk+c9bH/FyUllYbXp+Zg/2MzFNLo1Fx7rxc+xU5yBI5qGZDXrjoJZPJEI2UOYwrSxpqj/c3f32S3/z1SYxGDRNXwrz2qTbe+HQH7R0OWlpaaGtrAwSfrQcPHkgyic3NTTY3hfNuMBgYGxvDZDI1PT//M1AqlVCr1bLr9ImL+8cTJwTrBYVKpaJSqTy/gnVk1WBwyQlWTmH6r6LQ/zPY5HYOisSsTjBeiBcahe91KCSLDXE5SpYP9W3L1Ha2MR6njihVShVsbWYSNWL47GpjhE98UU6YdA4tb0Y2uTEvf7xYKBNqtTQQLIB7N7fpGXBRyJeoaGHrMMXenLyqkckUpfH/jk47nZ0OojFBlFxQcNA/O+o/uusvyCoOXd1OAgELBwcpHE5jU48jEDRTszMR9nbTqNXKxp3NBODRqODOHgiYcbqMqICLl4IszB9wcCD/3ly8FOLB/R1JG1RP8s6NBbDa9MeSvOERLyvLgj/VGgKBtlg1tLYa0Wi0rK+lGRj0Nj3eSgVy2SKzs1F2tlMEAmZOdTnJZIvMTB1I2XtKU42FQpmnRxYFbo+Rvj43BqOG08Neput0UCDE5zx+tCvZWTyomQptaTXS3u7GYNAea7MxMOhhdSUukapaY9WtrQQry4dcutzcqHRnJ41Wp6ZchkgkI1k5rK4csrlZ/b7UOsmLqNXkhcNWunqc5HNlxQlYEAjas6d75POCA79I5sQKVblckVqYzdDaambymVDFgqMqYIeDZDLL3GyUfL7CwJBZ8Xiz2RLvvrPG5LMDfuU/P8Zk1vL6p9p5/VNtXLwcwmDQMzExIT1/fn6e1VXh3OdyOW7cuAEI18vOzk5OnTrVdD//vHCSQ/jJwQnBesFxnE0DCC1CAG2dBiqnMP1XVpjaqzcEVYrZqa97VcqgtkO5ZnJeyfHdHDTKCFZ6R2FsXN0oqre3mmXu7UpWDSafQUawKnnwDNs5eFrdqVykgKPbQnwhhb5FxxdTeyxN5hi/GuLuNXkV5P6tHcX4G4D56SinL3op6ysYc819bjpP2cnlyrx/NOVnseo4M+pBpYLZacF88/KEYCmgZBy6uBBjfy9NW7ud5UVhEc7lS0xP7kskAhqn/GqnE0HQDvX2u9neSqLVqhTz6U51OUinCrJKBUDXUZvrIJLB4zFy/VrzhdVo0nJwkOXWzS2plejxmNjeTkl+TfWERUQqWWJmOoVer6Kj08TOTpSRMw729vJsb8mJwMCgm62tlGQ7UauDEkKX/fj95qatVhDIhlqjktloVHVQMDcbZWDQw+1bW021UIfxEvF4nslnm4IrfI/zqLV2ILWIz5z1MTcblQ0J1BqrajQqrrzUSrFY5syoX6oC1uLUKQfJZIG9PeEY66f8QmErJouW999ZbRoU4PGaMJq0UuC2SiU45Xt9Zvb30szNRhm/IOQo1lY3RUQOsqSSOwwMenn0cJeh014cTgObG0mZGeypLivb22kyNakRovM+CO3JNz7dyuFhFn+gzK7CNSAUtqBSqSQH+/m5GP/llx9js+l46ZVWXntdqG75Axa6urro6ekBhLbcgwcPyOVyVCoVlpaWWFpaAgTDz9HR0f8pJqdKBCudTp8QrI8hTgjWC45vReQOjW20crFx+q+goJ1S6+UEp5AqoTGpKWWqF0wlny21WUX5sCbsWIG8Gep0UZm9XIPmq5RVEMPXxeOk6w1BATQKIn5bow7L7DeSVOf5leUtYkfvOz8VxWTRkqkjbg9u7XDuUoAHt+QL9ZmrPj66tUH5yNPp7Dk/Wo2KJ4/3pMVx5IyP5aW4zEU8lSxIk2B6vZo3Pt1BOl3EH7BIfk21CLdY0WnVkimkuMAajVqpVaXVaLh1a1NxUQQhGNjuMEiCaJtNT/+A3KR0eMTH8nKcpILj+eJinOXlOBcuhpmejnDxUkjISpySj/u3twuWFWIrrVKRTyWGQhZGzvjYVYh3EeF0GgiGrDVCd2Hx9fl1BAJGslkwmw3MzsQUJxIBCoUSWp2ab7wpHG9Prwuf2OY6yh4U43P2NuX7UusvduWlFqKRLJcuh9jeSjUETHs8RpwuoyTwrw1sFl3h/QEz83XkqhYGg5qh0z6u1Ti4m81aTg/7pDakyy3osJpFDi0vxwmFrbzz1koDQRTNRgMBM3qDViK5IHw+tRWql19tI58rcuasj9mZSINOzWTW0t3tkshd7WCDOIyQy2eYm43LyFU9zo4GeLtmGKGj00EwaCYWyzA/F8Pp1JHN5ohGlCZOC/zJ15aIHGT5X37iyOT0U228/qk2xsZDGI1Grl69Kj1/amqKrS3hximdTssifPr7+wmHw033838EzYKeTzRYHz+cEKwXHM+tYAUMgLK+yuCUEywl01DFuByXnmSmJi5HgQSpDfJ/K4naFb2ownKHdaVJxnqymN7Jyqb/ACIKnkTZ/ca749V8nF+e2aBYcwixSJaLV0PcrqtilcsVHt/d5cLVEA9ub1MpQ/8lDx/cWJc959FRO8xm03N21IPVpuPm9ebWBkaThsFBr2yhEafe9g8EvUv/gBDRshlpPIZstsiD+ztMXGnh+vV1evuEKJytLXm2XSBgxmzRyRzKE4kqidBq1Xz62zrIZIq4nAZFgiVMNbolAfjtI52NwVB1Hc/lSiwtxSSPKyV0nnJKpMdi0TE84kOr1TA/HyFykCUYsmDQa2RThCL2dgvs7RY4PWxnaTFKe4cBrc7C2kqKRE0L22zW0tPrksX41GYPer0mzoz6SaXybG01EloRlydaZO7sIBBElxsKBRW5nIpyiaYTmPl8GbNFJ2mhOjrshMTcwqM2pMWi5VSXU9ZyBGGgQHxseNhLsVRmaMhLJCJ8L2orVFUPK2Ffawmi2Cb2+c0kk3nu321ezbs8EeajD9ak166dON1YTxCJZGjvsDedWt3aTGK1qlhZSaJWqRk958dg1LK8FJfsMlQqwRusfvhiZTkuVcD6+l24XCYKhSJUYkQV0iYuT4Sl9uTTJ/s8fbLPz//vD3C7jbz8aivf9tfaefmVNtweweR0cHAQECJ8Hj16RLFYpFKpMD09zfT0NAA2m42RkZE/c3WrWYswEAj8mV7vBH95OCFYLyhEDZZWq6VSqTQNTzX7jaBSlkPpLPKLwLcal6Oz62CzutArtehUcqN0UgqWC4pVrTqH9dRWpqGV2dD2qIAlZJJZPBR3Kxi9OrL7VWIXX0hJui+VRsVGX5Hfu7nD4IiHqSfyhfzZ4/2GHEEQ2jl3rm3RN+zGHtLzzbdXaIZkMo9Wq+bdt1exWHWcvxBEpYKZqaoHlddrwuU2NiystVNvL73USrFcwWTWkU4XZO1AOHIlP+uXhfrOzgh/E6sJlQqsrsZlhKseFy+F+OZb1ePxB/R0dDhJJQVDSqfLiMdjUtRT5XKC6/jYWICpyQNaWq0MDno5OJALosVg6FotVK1gXa1WcfVqC1qdWtGFXkStfiwxI1SeNBpo7zDgcBhJJktotTrJ00sJbe02rn20Ti5bkvygTGYdK0cDBVqtitGxgGSRUQuhzSW066hU8PlNtLRama8L04ZG7ZeYWwhCG3L4jA+jQcv9e81jaZRsFtweIz09wjDC4nyE3j5PUw+rcrlyNP15wN5uWsg8POUgly0yPX1ANvMcndoRmRKqYh4MejVnzvqYnjpoaGH299tYXEwe6QtLsu9L5ykH4bAVo1loYTZDR4edaCTH7IxAhsUWpsdjZHc3yeJCgsEhc1PtVySS5Z1vrjD57IB/+iPvMnrOL5mcjpzxY7PZeOWVV6TnP3r0iIMD4RqQSCRkET6nT5/G5/M13dd6nGiwPjk4IVgvOMQfsji50vB3nRqTx6BIZpRsERpadAou8Lq6mB0lwbxKI2dFxUypwexTidBp6qYNS7kylpBRln+oROgsAaOMYAE4u2xs71cX90oZ1IEK6ryKO74UHz4WFvCCgvVEKlHAYNQSbrOyuSavbgRaLeykUtx+e4uubiden4mnj/dkDutGk4ahIa+0WNW2A3U6IabF4TZysJdp8I2qxcSVFq5dW5dIpckktAN1esGeoFQsE26xSpWKemxtJvH5zSzMR1GpVJy/EEQNzM5GJQ8o0Sfrep2IfHcnz+6OsDgODnlwuY3ksiWsVl1DywiEaoKoUVqYj0kVHa/XRFePk1KhTLmMYjC0iMEhD48f70mt1FDIQkeng3S6wPTUAYVCmUuXw4qC91IJVldy+PzCglwu5zg9bCOfV7G4cEhtJ/3ipTD37la1bqIflIj+ATetrTY2NpJNcxb7B9xsbwvtutVVgTBJWiavib29DF6fSTEuSITBoGFzQ/DXqordDbI25PjFoBS4XYvIQZbbB1uSrUQmXWDiSgvra4cN5LSn18nBflYKqd7ZTknVJDHzMBAw8+RJ8++iy23E7TbKiKBYfdTpNCwuRPF4dczPJRR1fQBrq4d4vCauX9uQeX2JbvQgtAmTybyMqEotzKN/C6a5BUbPmZmbi5JKym86bDYdwZBVanneu7vDvbs7/G8/c5dg0MKrr7fyme/o5NJECzabgbNnz0rb7u3t8ezZM8rlMuVymSdPnkh/83g8nDlz5tgIn2YarJMW4ccPJwTrBYf4Qy4Wi+h0jRojENqEivoqhRZdgy2DApmp98vKKRClBuU7YKoz+1Sqainpucw+OcFSiseJ7DeOqpdLChFBZi1fNe0zO1/dj/npKMPnvDx9IF9cInsZ/CEzHd12VhaEBbRryMnSTpzoUQVPDNg1mwUrhkKhxM5OCqtV3zT2pFAogwoe3NshmcgLuiC/mb3dFPNzMWE/1QIJqF+cM5lqy6itzYYvILTSOk/ZZU7nIi5dDnHv7o60OIskT6NRMXTai8tlQK1W8+EHaw3bihBE5ElJiK3TCZoii0UnhRDXe1zVQnSbdzgNbKwnGT3nx2jUsrgQZXe3+h04Px7k6RN5jE+tINrpNHDufIBUsojbY1TM0jvVJQjARW3X/p5ABM1mNa1tRnR6HVaLvqE1VQuHw4AKpJaty2Wkp1fwdJqZPiCbrUjWBfWxRSIRmJ+LcvFSmIW5GJcuh8jnS0xNVStFAC2tViqVqg9WrdgdjnRqZ/3s7qTQaEBJCWA0aejrdTfYSrS12Whts5NI5KlUyqyuJGT6v1rksiXMZp3Usu085SAUshCPC9mQ5bJAkq1WfUMbtLb6OHjaxmE8z/nxILFYrqGFqdWqOHPWL30H61uYAwNuQkd+arVC+XpMXG2RmeZqtWqGTnux2bRsbAhWGza7qql9xfZ2islnB3z5D+aBChcuhY60W+309rnxeDy89tprwrnJ5Xjy5AmHh8Jv6+DgQIrw0Wq1nDlzpsHktJkG66SC9fGDqqI0W3+CTzyKxaIkbn/rrbeYmJho+gP+g89+RHQ+Sa7ORyl8xcvmdTmp8AzZOZisLtTmoJH0tnwhC1/1snlNvp3BpSMXrVY1jD0asvNyUhe67GHrprwVZ/IbydRk1bkH7ESm5UQhNOFh60bNdipBfF/OVb/6aguU08haiWJQswhdl54v7G2TVamJHsj1Qf6QjsheQXER0+rUjF0MkCkVuP1oWzHHT0RXt5NKpYLXa6ZUahR/g1DpuXtnW1GIHgha6OlxYjRq+eD9VUUbBxBIz+5OmkiNJqulxUp7h53DwzzTU/tcutSc9IAwSeZyGZmfi9LWbsNur5BKlVldSUseVGNjASYnD5qKyLVaFRNXhKk3JV0QCO2efL4kEaVaCKJzEwajEC6tND0JYLXq6DzllFpVarXqqGVUnUocOu1hfS2h6Ckl4uyoiyePo7S0GnA6jRwcFNjcqIrb/X4TZou+aZiyVqvi1dfbyWSKrCzHFY07xUzAetJjMGoYGPBgNGpJp/Nsb6WlQQUl1LbrTCYt/QMeDIaq55bNpqO1zd7UmBUEC4ydnTTt7XY0GiGcup6Y1uqY6uFwGDh71o9ao+Lhgx1JKF+PodN2pqcOZd5lbreR7h4XlUqFxcUY7e2OYyc5u3ucHBxkiEVz+HxmurqdFAolpqcOJCLbzFpEhN2up7vHhV6vJpXMMTcXJZeTf6eGR7zMzkbJK/yOOzrsvP6G4Ch/aaIFk0kn6wxsbm4yOzsrxeHUIhgMMjQ0xPz8PKVSif7+fulvr776Kj/1Uz/F5z73uab7foK/ejipYJ3gW3Jz37wdob5epeTKrjXX2zIoLFYKuiyDUy8jWKWkwkKpILS3+A0ygpXabqxqNZTjK+DosBKdrbZByilw9dlkj+UiBZw9VmLzSUpDWn7x2Tr5YoXxKyHuXpcL2He3CvSdtjNft0gAFIslMqoS00tRxs4HefZ0T3ERPzvqZ34+SipZkLROBqNGmvCbn4/S1+c5tmVUKZfZ3hbcui1WHWfOelCrYXam2tIbGxf2oT72ZGMjycZGEp1OxYWLYfKFEuMXgoq5gyLpEQXfa6vV8+Z0GejtdWN36Ll9c7MpubJYtHR1u2TVL9GeoJAvMzW1T2enk62tZNOpt/m5KH6fmffeWcPvN3Oq20kuW2Rqcp/cUXva4zXhdBpkoupyuSKbSnzplVZKxTJarVpRF6TRCGanoh/Z2mqOtVVhn7xeHYGgEbVaQ+Sg0JRcAZwfD8mMO+sF63qDht5el6JRaS4r6NTE1qLHbaK31yXF99QS03otVCZTlJGTs6N+3G6jZF2ghFrdlujsLpqyerwmdndSuN2mYz2sLFYdc3MRtrZSMr+unZ2q1cbpYTtTk42/m0gkS+T2FkajhoEhL/mcEL5db+UAAtHe201L3/G9vSr5FKcwQ2ELU8+ak0mHw4DPb5bpGQ1GDWdGPRj0KlZX4lhtGqanDyg2uXFZWTnk2dMDfu3/9wyTScuVl8JCdeuNDtra7ASDQWnaMJvN8vDhQ9JpYT+3t7fZ3hYrcmra29slk9N6m4bu7m4WFxelf7tcLiKR6vf5gw8+4Gd/9me5d+8eW1tbfPnLX+azn/1s02N/Hjo6OiR/MBGBQIBf//Vf59u//dtZWFjgu77ru5icnJQ9R6PRsLu7+7EJ2v7zxgnBOsG35OZeSBYxO9SUakamFduGdRqocr6M3q6VhTAr6bn0dYagxYNygzi9qDBFV28kmosV0Dt0sonGgsJ2BUPjgm3wNLZIDV4d+/oyX3hUXawe3d3BHzJLgcwiZp8dMnoxwOO7O9JiodWCr0/Ph9cFErG3l8Zg1HB+PEixWObZ0z2KxUpT/6pctsSD+zsYjRpOD/uIRrNMXGlhcyMhCZ1FdHc7SSSqeYCpZEFaqDUaFaeHvbS02Jie2m8gVyLsdj1t7XbZoim19Kw6VpcPcbqNrK8eNq30xKI5tFo1b7+1ciSgF8TftVNgXq8Jh9Mgm0gEuT3BhYtBisUKg4OehnageEznx6sO77u7aSl6RtCa+bBYtRzsZ4+t0oiaLPHcV6cS1czNRclkCgwMeCRyVY/9/QJWq4FIJEmhUKa334xer2NtJc1hTQC4UvWkVrDe0mqlq9tFJl3Abtcrnt/hER9LizFSqQLxWE4aZBDbkOVyGZNJx0c1Vg318PtNxGI5ySLB4zVJzv+i51Z9OLSISkUYgtAuCMMGy8vxoxamkFtYW23t6LCTzhQlclbfwgwEzXR0GohG8uj0GsXvpNGkoafHzcO6IY5wi5X2duH1i4XSsZVHIfJJzzf+dBmotj+TyTwz0wKZdjoNeLwm6YZBRC5b4vHReToz6ieZyHP+fJB4LMPcXIz6+9ILF4PcOdIIZjJF3n5r9Sj+5xr9/S7++nd2cfFSiIuXQuj1ei5fvixtu7S0xPLysjR0dOPGDT73uc+h0WjQarUyDZaYq+h0OonFYg3HnEqlOHv2LD/4gz/I5z//ecXzUguTyUQ2m1U0iwZYX1+Xnie63u/s7PAd3/Ed3Lt3j+XlZWZmhMkYt9tNLpcjlUpRKpX46le/yvd93/c9dx8+iThpEb6gKJVKEqm6du0avb29+P1+xefe/8V53vtnj3F3GkltVBc5e4fcsBOU24b1z3MP2YlM1rXxLnnYulXX/gvoyexUL5rWVhPJdfkiG77iYfO6fDtXv53oTPX1613ZAfQdavIr8sXDNWgjOlWtxGiMamZ6s3z1fqMWY+xykPs3lcXWojN7LJ7DFNDKYkrq4XIZGL8YYncnzeSzPcWWnsdrwuMxNZh2trXbaW21EYtl0RvUzM/FSCmIx6GqyRKJU0eng3DYQjSak6ofwZAFo0HL8jH6lfELQWLRLD6/hZ3dBIvz8s9RnPJrJkTv6nbS3mEjlShwp4mwHgTSc/eOnHDWas02N5L09rllJpn16O1zcbCfIRrNCtqYo6pLrQ7oytWWBnF+LRxOA4NDHlQqFdt1thUiTg97WV6ON5x7lQpa2wzYHTrsNjM3rjffV6/XhN1ukAiTVqumr9+Nw2GQyPTYWIBnz/abtpjVahi/IDjj9/e7pfieWsF6uEWogmw2qVzp9Wpeea2dVDLP6uqhYgtTrxeimuonVw0GDf0DHsxmLelUnvWNpKLOTcTwiJ2nT4Tvj9GopX/QjcmoZemIiJvNWjpPOY8d4hgY9HCwn6Gl1YrBoGV5KSaZxIo4Tt9nseiEGwCTlieP96S4onqcOetjejoiawtabXr6+l2oqLC4GCUUMjL5rPnkqj9gRqdVs7GRxGbX8/IrLbz+qXY+9ekOfD4zKpUKtVrNkydPMBgM7O/v85nPfKbxmAcGuH79Oi6XCxAq9PUVrIcPH3Lu3DnZdp2dnZJRai6X4yd/8if57//9vxOLxchkMlQqlaYEy2q10tXVxePHj1GpVLzxxhu8/fbb6PV6fvInf5Kf+qmfQq1WY7fbsdlsvPnmm1y+fJlkMsl3fud38kd/9EdNz8snGScVrBN8C15Ygp+L3q6TEayMQvuvoqCB0dcZdCr6ZWka2396t05GsFJbjRmBxUxjNczgkL9faivTEI+T3yg3GJ7G55PSFKTeo+VPdVEe309z9oKfR3fki+PD2zuMXvDz8E7jojk/HaW9x07HGYdkRqkEg0GFz6/nrSNxsOB75aYCTE/uk0oVBff2bKmBXIEwUbW2KjiyL8xHGRryKuq2BO8pj6wqVesX5HYbGT3nJ5stcf9+c9IzcaWFmzc2qFRg/oikuD0Gens95HNF1tcT+AOWY6f8jAYND+7tEo/n8PnNdHU5yeaE3EGxpddsQRQ9qFxuI/39HvRH3lnTU9VtRZw562NhPia50c/ORODIeiIQtHDqlB2rTc8H7zUX5/v9JixWPTevV8+baFuRTheYmtxn5IyfZ0+VSU+lAhvrOVwugVx5PFqCISOFoprFhYTUZgq3WFGBRK4AisWyjFi8+no7+VyJ3j4301P7DVN2er3gNSXm+YnxPSAQ8ZZWK6VShbXVw4ZMylqMnQ/y9lvLUrtR3DZxKGQP6vRq+nrdDeQKxEnKXXp6nezvZ3A6hM8pHs8yMx2RkeVacgWCF9ujGjuGwSEPoZCV7a0kajUN7UOAoSEPK6uHpGpc6UEg8cGAhWgsi8tlPJZA63RqdnfTEunu7nES8FuIRDPMTAt6QCVyBZBMVP3ALk+E2d/PcHkixN5uisXFQ1nL1u0xotOpJcKaOMzz9a8u8fWvLqFSwcgZL//sn19i4mqYUqmEyWTiypUrkjjebrdLUo7p6WncbjfRaLRBIC9CJFfd3d0sLCygUqlYXl7m7/ydv8Pv//7v8yM/8iNMTk7yO7/zO1LAdbFYZG5ujt7eXvlxJpOkUin+xt/4G9JjuZzQAcjn87jdbt58801AqJxls1lGRkYksqbX13nuvEA4IVgneL6buxiXUxd7U0gUGww6iwoLjdb0fL+sUl5hO7O83VgpVbC1m0msVi+mmYPGVp9aKydr5WIF54CV2HTN3XgRnENWDh5XL/LlQgXPkI14LM1v7G+zvS0szge7mYaLfLlc4emDPUbGfDy5L29z9Y26mVw6ILm4h1ar5vx4kEKxzJNHu9JFV1i8dczWVNpqTTv1ejVvfFs72WyZ2enm7a1arY04bWcwaiRzxv29FCqV+lhxcHuH0BJMp4tH2wYwGNSSJ1OziUSAyEGOWwebBAJmXG4TOp2aS5fDzM9HG/ycxs4fVWCOWkF7u2mpfWQyaTk/7sPtNsniZuoRDlvRaFQ8qDkes1nL2HkfWp2a+bko3d0uHj7YUbTPEPY5TVubjW9+Y0XRpBSOnOQLpYaK1dZmUnLJv/pSC9lskTNH2Y/ROhNXvUHN6dPVSs/BQZGDA2Fbo1HNqVPCZF0kUmRl+Tij0jAfvFeNrREqJ240asGeIJst0tfrbjp1urZ6iMGg5mA/S7FYFqw26qwNQNnDSiTxAMGghb4BN5l0AafToChYHxh0s7GeJJHIE4vmpGqow2Ggt88FVCgU0jx62DixKsJu11MqVXjnyCPO4TTQ2+tCpVIxOxMhHs9xetjL0mKsYQoTqpO5E1fCTE7uc+FiiAoVKU5KhNNlwO02ySqatfYgTpeB8xdCJA/zGA0aRVE7yEX+80c+EELL1kmhUGR3J0mxVFasBoJAxMNhG5cmwuTzeZLJJH6/n3w+j1qtlm5+NzY2CAQCPHnyhB/6oR9qSq7+8T/+xwD8xE/8BD/zMz+DSqXiS1/6Ep/73Of4gz/4A1ZXV/nVX/1VVldXJT2YKBP51V/9Vf7dv/t3stebnZ0FkOUw3rlzR/JS/O7v/m5+7ud+DhA6I6VSSaZ73dtr7iX3ScdJi/AFRblcplAQCMSDBw9wOp1Ng0yj80l+dewbtL3kYfeWvFxvCRtJ1ZiGOnttxObkZXKltmG9X5ajy9oQnuwesxK5L3/MP+Zit6Zlp9apqJQrVGqufcELbrbvyCs+xgE12Wn5ghu85GL7lrz9p76o55furJPOy38WY5cC3L/VuIDpDRrOjPm4e5QxOHLFx/U7G4rTbD6fme4eJ+VymeWlQ0kvpITBISuzMylKpcqRN5KYwye0qURNlpIYWoRY/bLZDYrO7KDcihOhUsHpYR/BoJn5+VhT8XZXt5NkIi87HnGfvV4Tm5tJgkHLsTl8JrOWvqOWn0oF/f1uXB6TrC3X0+skFs1JRFIJV662EIlkcLlNii09UVhfr/0CYbKwr89FqMXK/l5G8Tki6smIOJWo0xU5OMiRTJRpa3cc297q6XWwvZUilS7S2mrA4TAQj5dYW61WmJ439eZ0GhgY8qBCJX036jE05GF1LdHgrK9Wq+gfcON0GjEY1bz3TvNqnt2uJxiySpVUtVpFX78bl8vI1pbgwzU07GVlKS5VDZVwetjG1GSC/gFB7F6/z06nAa/P3KCFEqHRqHjl1XYKhRIbG4mmxrdKZFGjEY7X4TASi2XJZUuyqmE9zpz1MTMTIZctybat3efjJihBaO87HAaMRi02m47NzUPZ5wvw6mthfu0L34VaXeHu3bs4nU56e3ullt309DRXr15lfX2dlpaWhveobxH6/f5jSc1Xv/pV/ubf/JtN/14Li8XCt3/7t/OlL32JX/7lX+Yf/aN/JCNPRqORTCbD933f9/Gbv/mb6PV6fumXfol/8k/+iaTpstlsUiXuRcNJBesE30IeoaHp3wwOnYxg5eLNR9xlrxkyEV+okqfkZrpR1K6QQdaQiVioYG0zkVyrLrqKFbLDxoW91lML4PA0fOHOBjaHgXSdV9b6SgKn20CsLqw6nytx98Y2AyNu7AED33hnueF9ROztpWltszIzHcFi0XN5IkwqJbSaals+l6+EZW0pUVgsYmDQQzBkYW83jUajUiRHwyM+VpaF7MKtrZTkzN7SYqWtw04insPhPL594nIbyedLkju716snGDJSqeiZPopoaZY7KO7z7Iyw2K2sxLl0KUQiWWhocbk9gsO7qKeqVJDp1kJhK6eHvUQj2WMn9CauNOqphJaeg1Qqz852EofT2JQ4lcsVdHoNt29ukUoVGtqBoj5OafGunUoU7QUMRi1nzvpk24oYOeNjYb7qg7W2mmON3NF51xIKGXA4Tdy93XzxFo07ZS3MOmPVgUFPQzh07T5PTR4wcSXMe++s1WxbZGa62nYV36f2O1guV2QxRFdeaqFSge5eFzMKLVuAoWErz54KN1+1Yvfg0fsW82USybxiO1zE6WEv16+vS1XQYMhCR4eDXK7I9NQB2WyJyxPK1dZSqcLkswNcbiMOh4FstsjliTCZbJGZo21F1JKr2m2l8xy2MjziZW83jdGkkfmTiXB7jNisellmIwgt6s5OO6lUDrtDw//tR/xcu/YBarUai8VCR0eH1Fbb2dnhB37gBxgfH/+Wo3JEEfp3fdd3YTQa+b3f+z0mJiZoa2ujv79fEsh/5jOfkcjSm2++SblclrZJJBJcunSJ7/3e70WtVvOlL32JpaUlzpw5I71PMBiU/l+ssuXzeX7wB39Qtj+JRHNd2icdJxWsFxS1FazJyUk0Go3Md6UePx/6Cv4zTvbvyu/IA2MudmorSloV5Tp9SPCih+3b8jZX4IKbnboqU73jusGnI7cnvxtW8sLyjTrZexiT/q0xqoVJnBr/GpVa0JDlYnWhs34DuViemY4cX5sUjuP8RJB7NxorQ509DiK7mYZpJaNFS3jAyv0HO5w956dUrCjmrE1cCXPrZmMVR3SkBuEu+9ZN5Wk1EIKKQc3errAYOxwG+vrdRwueoNu6eEkQOjdrkYnROHOzUXr7XFQQ4ndq3dXb2myUy5WmY/x2u55LE2EOYzkmJ/cbbBxAELyPngs2TN+JAdEA0WiGXLbM+nrzi/CFiyGp5Wc92lYNzMwILR+tVsW5scb3qUU4bMVi1WGzG4TW2mykocV1/kKQJ492GywaQLAbGBz04HYbuX17q2lOYjBkQafTSG01EITU/QNuaSrxVJeTp4+V3wcEsfqZUQ8P7x9gNAoGp0ajjo2NLNFINXDZYNSyutK8MnDxUphisYRWq2ZhoTGCR6US4o2Uvm8mk5aBQQ8mk5ZEIn9sNW90LMBUjfhe3FZv0LB0NP05OGRlarJ5G9TrFfRuuzsp+gc8GI0alhblgvXRc36mJg+aivyNRg1XX2olmSywvFydWK2F22PEbjc0EHVRZG80aKFS4cHD3aYtQZBXrkR/MpNJ+Dw2N5M4XQZcLuOx0VKvvtbGr//Wd6JSlbh79640LXjz5k1+4Rd+gcuXL3P79m0uXbrEb//2bzeYj4qor2B97nOf4w//8A/p7u5mfn4elUols2mYnZ2lv7+fDz74gJdffhl4/hSh2WymXC6Tz+epVCpcunSJO3fu8G3f9m386Z/+KQsLC/T09ACCIP7rX/863/M938PW1pZU5XoRcVLBekFRW+Z9nsgdBKF7USmUuc6VvVysNJiGKumr6t3cAcx+g4xg5fYLqA1yQ9B8UsGqoU4bVsqW0XeqyC9XH6uUwd5lYe9+TPZc0ykD31g74N5k9WL86O4uoRYrW3XkYnk+Ts+Ai4oKEkeVOm/QRMWm4v6RJkgU6oZCFjpPOdnaSrC6cnikYVKuRhwe5llcjOHzmVleikuhx/NzUVk7bOi0l/W1Qw4Pq4t7PJ6TiIXBoOHT39ZJIpnH5TI02BqAQIxa2+yS1qtW83XmrA+zWUcuX2Jp8fiw5dMjPkmcr9OpGRkRbByWj3L4rFYdp7qciqRH1Jr19bk5PCwQ8Jtpa7ezshJvmG6rFdaDICy+VxMuPXrOj9dnZnqqeSuuu9vJ4WFe5swtOtE7nAY21hKEW6zHtjBLxTKlUoVvvLksBR87nUY21g9ZPfIA6+h0kM0UZOQK5G7llybCHMZznB8PKbb06k1Gs9ky83NVD6qWVj0+v4liQc3TJ8ptNBDsAu7fq5rRShE8PjN7OymWl+OMjgWakvlMpsj2dgq1CjY3k9IE5/5eWnYelewcatMC1Go4c9YGKg39A26Z95iIQMCMXq+Rhi5q9YKi6FytVXHn1taxJr1nzwVkgeenuhyEglZisSzT0we43CZsVmUTWFFkL1auwiErobBVUaB/eaJFli8p+pOJGDrtwR8QKsxarUox9ufqS6382he+E42mwr17D7DZbAwPD6NWq+np6UGj0fBv/s2/IZfL8Sd/8id893d/N3/9r/91/sbf+BsEg0G+9rWvybRSh4eHXL16lbNnz/LlL38ZlUrFwsICNpsNEHRZn//853G5XBwcHPC93/u9fN/3fR//4T/8B86dOycZn37ta1+TidlF6PV64vHqebt37x7lcplz584Rj8cxGKpdjo6ODr74xS+ytSV8t37gB36g6Wf2ScdJBesFRaVSIZ8XSMLCwgKpVEpW/q3H7377+6T3c6SXn6+vsp+yyHL9HF0W4ovyu8ngRTfbt+UX29CEl60b8teq39bkNZDZly/8SlUtJc1V4KKLndvVxUHfquctY4QHU413us00VwAuj5GOLjvRwxwb0cSxmiCrVcfIGT+ohPy2+nYBCH5BhWK5gVyIpo5ujwmNGm7f2mpa9dBooLfPyvRUUtq2p1dYUMX3DYet6HTqBv8s2XGfDzD5TAhbdrl0bGzE2dqsVuzUarhwKdw0FBiESoPTZWRjPclckynKs6N+5mYjDSJlMWYlEsngdpuaVrvtywABAABJREFUklIQRMh+v0VqKXV02Am32IgfLajlMgwNe1lbOWwa8wJI+XutbTbih3mmJ/dlAw02m+5YPVUgYGR4JMDhYZ4H97eb5ugp6alq25DLSzE6TzmPDZju7LQTj2eJRvM4XVrCYSOlkjCVKLYhL10Oc/vWpmL+IQhk+vx4kHIZWWutFm1tNvKFsmIVyOs10dXtxGrVc+f2pmL1EoTvZHePmdmZGosWj5HubhelkuC5ZbUZ0GpUxxqejp0P8OTxHlar/sjrq8LsjNz89tJl5UqciI5OB62tVnI5YSJXyTOr2bRgNfMQDEYtH33Q3GPM4TDg9VWF81abnv5+t8wF//JEmN/63b+FXi8QFZPJxMjIiOT4Ho/H+c7v/E7C4TBf/OIXmZyc5Gtf+5pUFfqn//SfcurUKZaXlxX3oVKp8IUvfIF/8A/+QcPfAoEA29vbFAoF/u2//bf8xm/8BhsbG1I34/Hjx4yMjDRsd1x24vd///czOjrKj/3Yjyn+vbZS9qLhhGC9oKglWMvLy0Sj0QbflFp89ftvsfbhHuX488mNd8TJ/pOY9G+NUS2EPtd80+pd00Eh0gYInHezc0++SGstGoqp6kXQO+Jg/0ldyb9FS3ZDvnibA0bSO0KFTNOn41cWt0hkSgyP+nj6sHFRU3JsFzE47iVVKoAKyYiwHoGgBYtZJxPStrbaaGu3C3fVUwecHvayutLctBOqC7OwrU2W8QZVc9BnT5tXcS5cCqHXq4nH8kxN7ivqtpq1MANBC52nHGQyBXQaNfeaTKuBsJDlckXJCkCMLMnlqu7qFy+FuH9vRzHqB6qtxcXFGN3dTgoFwdW9VucSClvRatUN1SIRLpeR8YtBYrEsz57sK06bqVQCGakXKUtt10qFvZ20FIzdDCNnfCwuCJYQYvtThTwQ+zgvJhA+w85TTnQ6NRqNijmFqcT+ATfbWynpNWthMKhpazfg9ZqZm01yoDBdC9Xswcc1LT+ZB9ViDLNZx2Ei39BSrMWliTC3b26i12sYGPRgPGqPiROWWq2KU10m5mabD3K0t9vwBy1oNWrW1w9ZX2skWefHgzx62BhUrdWq6R9wY7frMRg0vPduc4G+x2vCepR7CXKxuyjQr9dcKUH8fYgRSzt1nmp2ux5/wNJUoK9SwXd9tpef+49vYDCquX//PjqdjrNnz0rkKpFI8NnPfhaHw8FXvvIVWWUIhOv2cWTnBH+1cEKwXlDUEqz19XW2tra4cOFC0+e/+xOPePgrC+h1yKJu/Odc7D6QX1CUNFfWsJFkjRheZ9VSqGv3+c442Xsckz2mlFvo7LUSm6tejLVGDcVSCepupI0ePdkDOXGxdZjZtWb5r4+3ELOcT/U6WJprbBuoVDB2Kci9OkPRMy/5+fDGmlQhECsnc7MRqZrV1+cmEskcW9166ZVWCvkyuXyJqWd7DcLgZhomEKo3fX3CXXU0mjtWGNzVY2JjLSe9vt2up3/AQ7lSYXpSIB+CMPh4QbXPZ2ZzM0l/vxu1WsXM9IGMGA6d9rCxnlQkACDYKVx9qZV4PM/cXKSBQIAw5dfd7ZIRABB0LoODXgwGNel04bk5fJcmwtw5avnp9eojPZFOMqJslvdXi3CLFZ1Wjc1uwGbTK7Ywx8aDTfVUGo2KgUEPLa1WpicjrDYhg2KUT+1iXTult72VxGLVsbR4/ITehUsB7tzaQaWCcFiPy2MkcViWLCCsVh3tHc+bbHRhMGiw2w0cHGQUv1f1Qxi16DzlIBA0kcskefw4qehfBUcVsnxJprESjXMPD4UbiHPnAzy4t9M0X1KlEvR5t29tSTcuyaSQoylW87xeE2aL7lit2tWXWiiXK6TTRUVPNRDIldLvw+83c6rLSbFYIpct8/Rp8+rj2PkAv/v7n8Vk1nD//n20Wi2jo6MSuUqlUnz+85/HYDDwx3/8x1JMzgk+vjghWC8wRLO4ra0tlpeXmZiYaPrc2/9hho/+1TMcIT3ZmhadUiVKiRT5zjrZexSTPVbf7qsXuYMyWVOyYRA0V/Kvsn/cxe7dKvlTaVVsnS3yOzcbF5hmpqFqtYrzl4M8urdDuVSh96KHGzeVKxGiNicYtDA5uc/WZnNDx/qKhtksCIO1WjWzMxHK5cpzq1K9fS4ikSzJZF4iH6J3lYjLE+FjtUVWq47x8RDZXJHFxRi7O42kpbXNChVVgxC9toqgVsHduztNNTL11aJaAiE6ldeGRzfD6WEva6uHBENWvN5qUHMtnmdtMHTaQyhsZXXlUKYnqkVXt5PDeKMlRGubBZutQrGgw+01c+fWdtNzq9WqGD0XkHRuAoGwHoVpC1OYwZAFnVYtc1uvx7kxP5FIllDIRiolJxDSMU+EudEscNmppb3diMlk4NHDqCKBAGE6dWM9IWunSjE6BSEK5+xo4NgsTINBTbjFwNJiBqfTQG+fUAmcq2nLCS3R4rEE+epLLeRyJVQqmJuNNgwkqNVCrqPSzYc4VGA0ajk8zPH0SfPfUH1bUAzFrhXZK02N1sJq1dHSamN5KS452a+uHsrI+Jmzfn7/Dz+HxaLl/v37qNVqRkdHJeF6JpPh7/7dv0u5XObrX/86ZrO56fud4OODE4L1AkOcCNnd3WV2dpaXXnqp6XOf/dYKb/7wPXyDVg7nq4tBbdtNhFLbUEmr5Rl2cPC0pnKkAo1BblzqHrATmZbffSq9lnFQTXaqTnN1wcXOHWEB1do03HAleLyfoVSEdEpePQuGLRTy5aZtkZ4hF84WI998e1nx7yJEUbZKJVQvHA4h/kTUshgMakbO+KVFVwmtbTZCIaEFplQ1AWHRnZlu1DBJHlJuI0ajlnffWW3YVoTFqsbrNbCyXD3m1jYjra0u9vYyLMzH6B9ws7uTJhptHnkycaWFWzc3ae+wEw5Z2a+rfBgMQrRKMyNMECbR7HY9+3tpWfuzFmPjQZ492WsgcaK9QDKZx2YzHLsYutxGvF6TRKxEN/naFubQkIf19ebZduIxz8wcSHqi6akD2WdhNGno7/c0jfJxOAycGwtQKpV59HC36XtduChMhNa2yCxWHQMDHjQaFQsLgrGq6OCuBI/HhNmiYW01id6goq3NiMmkZ3MzJxmrHmfcKeLqSy0kEnnM5uowQy1MJg3+gI6V5cbvikjGfT4zu3tpJo+5cbh4OcTd21XiWuvXtb2dZHXlkHPnm8cxAfh8JowmHetrh5IWsV6g30xzVYvXP9VOLlsiGhMCteu/lxaLlrY2u2IclljZtlp1/Px//mvYbDoePnxIpVLh3LlzErnK5XJ8z/d8D6lUijfffFMW6nyCjzdOCNYLDJFgRSIRnjx5wquvvtr0ucvf3OFLn79GeNzJwSO50We57m66gTihLGBX0lw5uq0yf6z64GZoNBsFZSG92CLUh3R8KbvH/JG1wYWrIe5ca1yQOrrsRCM5DuvuloNtFtKaIqurh3R2OggEzTx7ui+zNdBoVIxfCDYV2vb0uAiGLVTKFa591JwA9A+42dtLyzLcTnU5CAat7O8LC8TzqlIGg5rhET/37m5LwbbxuBB4LP7awy2CI/raavPKyUsvt1IuV0gk8g1eXSKatYu8XhPdPS4KhSKFQuXYMf++Pjf7+2kiRy1Dp8tAb69bRlyed8x6vUBcZ2Yigo2DqrGFGQpb0WpUTatFJpOWKy+3kE4WmZ2NNCXbShUNg0Ej2RpsbyUxmXXHBkz39Do52M8SjWZllcC1taoW6XlidcGeIkAiUTgy/EywvCS/GQkELeh0atYVjlmlglBIT2urhUi0xPxc8zaa0jF3nnIQDlmJxrKsr8VxujSsrTafPO3ucRI5EI5Z/F4mDnNMTx9I363LE2Fu3Wx+zBqNissTYYqlCtmMcksvEDCj02sUj9nrNdHV48Ro1PDk0R7RYyZl649Z/F5WKhVmZyIUi2U6Oh3Hfs6DQx7+4Cufx+HQ8+jRI0qlEufOnUOrFSaf8/k83/u938v+/j7f+MY3cDgcTV/rBB8/nBCsFxgiwYrH49y9e5c33nij6XP3nsT4zavv0HbFze4d+QXF4JT7SylN+ikJ0ZUqUYFxNzt35XeD9a+vNaspZstQdzdp9OrJ7ssrAfoxI//16TqRGlG8xaZDrVZJVgu16Oo7ag3tCItr97CLha1og2WByaRleMRHvlBiZTlOW5v9WBLR3m6nXK6wvi5YAnR0OIgf5mQTa+IEXzarXEVQqeClV9oo5EsN5pcinE4DobBV8aLvdhvp6XWh06lZXIixdUwm3cCgMP0l7lutd9XMtLCPZ0cDx1biAkELRqOWvd3UUftT06C9OjPqZ15hmlCEwaDh5VfaSCTzkqdSPaxWHZ2nnA3eY7XEJZMusLGROrYtVVstqq0ErqxE2dwQIoPGL4a4fcy0mqinogL+oKWhagJCi3J1tdFZXURHh53+ATfr64mm1TyjUUP/oEeW3wcCcW5vF4xVDw9z5HKlY7MHR8/5ePpEIM8Oh4Zwi4lKRcPyUoLsUSX5eW7ldrsOr0+D1WpGp9czO33QMFnY2+didyetqM8To388LgP37u80DYjWalWcHZXr5uo9t1QqFTqd5lhfNVHQXilXGBjwYLboWFuTB1s/byjBZtNx5oyfcgVFYgvCzdIffOXzuN1GHj16RKFQYGxsTCJXhUKB7//+72d1dZW3335bCm8+wScHJwTrBUahUKBcLpNKpbh27Rp/7a/9tabPTe9l+aXur9P+spedm/KFzNljJTYvb2PpbFoKiZrAYZ+BzJ784qokkFfSb7kH7USm5BcwfbuK/GrdtNtFNzs11g+FIQ1vl+JMP21cYJpVsUAgYAOnPWQpcudhc2sEEAws7Q5BBF0olhXF6kPDXjbWEoqLiyhWt9v1XL+20ZRoGI0ahk57ZW020XRTpRKMQu0OA2p188k6EFpxM1NCJaunz04hn2V7u0g8Vl3smwl6RbhcRoaGvZSKZZaWlA0du7qdJBJ5KWtQRLXdY0CtUXPrxmbTaUK1WiA9tVXBnl6X0GbaFSa4vhXdltjyc7mNhMM2olGh3VN75Zu4IpCIZlfD9g4bvX1udrbTimHLIFTINBpVQ+WkdpJSrVIxOdmcRIN8cRerJuVKRTKDtVi0dJ5yHqvP6zxlp1wSWqAajYrZ2UjDTcKFiyHu39tWFJHr9Spa2wUbjPm5FPt7yqTH4dBjtiCz8tDp1PT3u7EdVeSsVr2UT9gMYrWovh0o+oRptSrOnPUf22YOBC2EwlZMRm1Tgf5x04JiS89s0fLeO6tNxfVGk4bubpfs/It2G5mjqlp7u4Mv/dHfxuM18vjxY3K5HGNjY+h0QhB9sVjkh37oh5ienubdd9/F4/E0Pa4TfHxxYjR6AjQaDeVymXK5LE201MPkNQgu7QotGoOzMS3dGjYRnakuNJm9XIO9Qn2VC2hoN4IQx1MPZ9DB7mqsbmNhW5UadgbK/PajHTQaFS3tVjZW5QTw7vUtzl9unBAESCXz5LUltnZSnB0NNF2EBgYFfdLmZvW1hfBgP2q1iumpfQYGvTx6uNOUpB3Gc6jVKr751gpGo5ZzYwF0ejVzs9UxfbdHmOCrX1xqTTeHTnswGrXo9RryuaJsOkvE5Ykwd25XcwefPq7myg0OeXC5jOh0Kt5/r7nPj9OpwWiqcO3D6nO6e5yCseJOivn5GMMjXpaXDxUrNNV4lhaufbguTY7FY1mmpqqkx2jUMDjkbWi5zs9FJTI1POLF7TYSi+bQ6VQN1TwQPLmmp4RA5MPDPCvLAvkUq3nFQhmzRctHHzavVlgsWux2I28fRQZJVgw1bciOTgeZdIGtzcbzvrcnTDyOXwgyMx1hcMiDXq9RDMS+PBGWVU5i0aqRrE6nZvxCCIdDz9TUce1HF/v7aWLRnDS5WDVHNbC9lcIfMHPndnOBfrFYwemwcfO6cDMVCuvxeo0kk2WWjjJDXW4Den1FRq4ACoUyT4/Ix9BpD/lcieERH/HDHDNH4v5aCIReOGbx+yEiGLJw6pQTs1nHRx821xMGgha0GhUPa4LCJYF+UfDc6u5xHWvFsLJySLjFxttvrWCz6ek7ajXXhmIbjRp6etwN1dLaEPDBIQ+/+wefxeM18uTJE7LZLOfPn5fIValU4od/+Id59uzZCbn6hOOkgvUCQ6xgFYtFvvnNb/LGG29IFwEl/HL/17G3mog8lN8ZKlWdlIxE6ycOVRoVqKFSszC6+m0yYtbsteqtGgCMbj2FXJH7/hTvzlarOMdNCJ4575P9zWDU0H7GwZ271YXd4zXR1+eWtQLOXwjy9Mnesb45V19qIXGYx2TWsbgQZW9PvphaLFp6et2KQmi1WsXAoCAKjsVyTcXSoNxaFJ23d7dTLCzEnjsJZbPp6OgU2mwi6amv9HSeEqa/lCYNRbzyaiuFQoVUKq/YwhSmCeVO2CJE0iNEclR4/Kj5MXf3OInFchJBEQ0da+0jnue3JVbIHj7claJOFubln5PTZcDnMzedNtRq1Vx9qZVypczSYkzRywmUpzlrQ7x3d5O43eZj4348XhMOu0HyVRM1UJGaz2lwyMP6WuK51aKVlbjUSqyfSlRqxdXCbtfQ0WmiXCmzMJeVWon1UBLOOxwGevtcqFQqZmciDJ32Hvu91OvVDJ328vDBbrUdqBda3OLnFAxZUKtVisMgIkbH/JRLFczmxnagdF6aTJ+KE68ejxGNRs0H7zf33Oo85eBLX/k8wZCFp0+fkkqlOH/+vJQtWC6X+ZEf+RFu3LjBe++9RygUavpaJ/j444RgvcAQCValUuHNN9/ktddew2g0Nn3+b736DqV8mcSsXEulZJugpK9SIkr2DjOHK9UFW2/XkT+U6zfUVijXXw9VR9qsmkgevU/H+44ot+qc2VUq6Ox2sDTf6HWl0agYuyTYMJhtOgw+LTPHeUp1OenpczIzHZGqIfXQ69WcHQ3IFsvaxXRjI0E2U8BmNxxrYFnrKyUupnv7GZk7ujjBd5z4+8LFEOVShUQyz+Sz/QZNTyBgxmLRywxRRbg9Aukx6DVMTR2wv9fc12tgyMzMVFoiZFJu4FGlJ5stMnLGf6z3VCBgxmTSsbWdFAwsDRoW5mMyu4TTw15WVpQrZCCQnldfbyedKrC6GldcTPV6NcMjjZONKhW0tBhxe4xUKloO4/ljne+HR7wyf6qOTgfhsFUykq1UlAXi9ftyetjH1laSzqOg5npyGgha0Oua2zm43UbGzgek3MBmrWalfamdSlxZjhMK22RxNfXw+Y2UyyUO9gvodCra2o1YLHq2t7LsHckARs74mJuNHtsKvfpSC9FoFoejatVRf14Gh7yKNxcqFXR3uwi3Wsmki8cSU6VpwfYOOy0tVc+ti5fDx1p7GAxq+gc8PH60RyBo4dQpB9ms3AW/rd3Ol//4b9PSYuXZs2ccHh4yPj4ukatKpcKP/diP8fbbb/PBBx/Q0tLS9P1O8MnACcF6gVEsFimVhIvDN77xDa5cuXLsiPCX/+51du5HKcXkegwlDZaSA7sS6VKaCFQyCDW2asmuyy/WtYHR+k49v76zhb3FwtxUI5Hq7nexuZ4gk1K+4I9c8IEFPvpw/diprbHzQWkkXoh1sUp6IBBE5uEWK5PPmrdwunuc6PUanE4D0WiuQQ8EMH4xyJNHjZYEIOhqursd2Gx63nt3VbE1BtXcwVpjSYtFw8Cglwoqpif3CQQtpFMFxZaiiPMXgjx9vHdUVfOg02mYnT2QaXqOM58E4bycHvFRKpVZXmoc8YejLL9ssUHTJZJTr9eESqXi7p3jM+nqSURHp/1Ie5VhZjqC2azlVJdLMZBbRFu7jXxeELt3djpIpwpM1VV6xsYCPKsJOa6H221kfDzE/kG6wcZBhMmspafH1TAgIXo5aTRq4vEMh4eF48XqNYHLkrGqWcdyjUbuecJto0lDX5+HQqGE06k8lRgMmsjlC0Qjyr+jYEhPW5uZWKzM/Nxh09+SUrWopcVKe4eDZCLP4mKU7h7XsbFBobBwrdraTEpTq/l8ienpAzJH5/pbsWJ4+ZVW0ukiarW8HSjiOKInuuD7fGb+3c+8RlubjcnJSWKxGOPj45ITe6VS4Sd+4if46le/ygcffEBHR0fT/TnBJwcnGqwTAKDVaiWy1Qz2djNLb25jdcld2JObjVWNbKRRX1VS0CFpjY0J8bY2cwPBcrU72VqXkzMxMaIyqOX/mFonW6iwcxhn6KyXyUfy5y7MRBkc8bAwGyVfJ0LvP+fm/swOqWSBtjYbLa02piYPZKJ0MY6m1m9oeSkuBceGW6z09bvJ50rHVivOjvqZn4vKHLndHiO9vS6yuRLTk/uMnQ8eK7hOHObI58u89Y0VrDY9Z0fdcCR0F6e3giELRoO2wbU7lSpx7+6OtC8ajYpAwEKpVFF0na8Xf1dDfFUMnRYCj3V6De+/21wf43BoMJmR6ba6up0EgkIg7vxclIFBD1tbSeKxxu9NpQKzMxFc7jB3bm0SCllo77DLDDtBqEaeHw82nP+V5UOp2njqlEPa1mjSyOJ3RPT2udjfy0jeXyKxsVh1nDnrQa0GrVbD7Vubx7qM9/W7+cY3lgBhGlIM0xYNLO12PeEWm+L0qRgQfarLQTJZwOs1ceqUk83NpBSKLGL8QpCHD6pxMvl8WUZMunuc9PQ4WW5ScQWhXd3R6Wxoy9ZOJcZiKRKHeWKx5lWpQNDBwwcHFAplbHYNLS1G1GoNS0spMmnhXF+50sJ1hWrRxkaSjY2kNNChUqm4eCmkGBsUDlupVCrSJOz+fjU1QTzXPp+ZubnjydXE1RY+rMkWFG8iXG4jO9sp1tcOpRalErLZIrvbKX7lv34HbW02pqamiMVinD9/Xkau/sW/+Bd85StfOSFXLxhOKlgvMGorWO+//z7Dw8PHCi4f/PIC7/4/H+E/bSVe595uDhhI71QXR41BTakgt1Ko97gCCF3ysHVLXu0xD2lJT8ov4u4hG5FJ+XuafHq2/Hl+7aG8ndHd72RhJqZ4DKdHvawtJySvq5GrPq7f3mhYKA0GDcMjviOfsCylUuXY6byhIQ+bW0li0ZygJepzUciXmJqsthAuTYS5WyMyr4dGo+LipTC5fBGNWsXMdGMorcttxO83M6NgbKjTqRkc9OB0C/EqszPNJ+suXAzJxPe1LUxxEf9WHKxFewSx5RKNZpiequ5be7udfOF4qwAhqoSmui1oro+panoAVMe2igJBCwaDRopNMRq1DAy6UasrzM9FODwscXrYy/JynFSyeSTNxJUwd+9s09vnxuEwsLYWl2mv6h3clTB6zo/LZWRtLdF0ArKv383OTqqBdIqZlIlEHotFd6xYXaWCi5cEbyk4En73OCnmy0wdVXrsdj3hsFXRLFN6zzYzuVyBcNiBXq9TrPQ0yw0Uz0lbu4FA0MziQprdHeWpRKNJQ2+vW0Y61WoVvX0u3B4TO9spcrkSxaJyELWI2mlBMUA8FsvJzEKvXFUmerX7fOFiiHKZo3agkueWhS//8d/mVJeD6elpDg4OGB8fl0kt/vW//tf8+q//Oh988AG9vb1N3+8EnzycEKwXGKVSiWJRIDLXrl2jt7cXv9/f9Pkr7+7yB3/rI1on3OzdlZMipRxBa6uJ5Hq1KqI1aijWicLdQ3Yik3LiovWrKO7Kv5ZqnQq1Xi1NIaoNaibbsiyqCsxONmpsRi8EeHhHWUfidBvp7LZT0Fe4dqP5xBwIxCkWyxFusVKuwNTkvtR+EFFPVmphMmkZHPLg8Zq4fXOraU6f1aqjq9spqzxotUKrx2oVqh56vYZKheM9fkb9LBxVyLq67RgMRRIJWF+rtgBFt/lmv3y9Xs2FS2HKpUqDQakIn8+EzW5oiKkBYRHv6XGi1amZn40e237sHzAxN5uRFj1RDySK1ROJvGIgcy3sdj0trTYW5qP0D3iwWKpVIhHilN/urvK+qFTw2usd5PMlNjcSLC01tpmhuZ5KHPGPx7PoDRoe3m8u0K/XU/n9Zk51O2XGmUPDXlaeQ/QuXwkz9eyA3j4XqGC2jpAfFycDwkDH6Kgfi0XPs6d7TT+njk4rB/sZksnqb7fWTmFrK4HPZ2k6bSviwsUAd27vHJ0DHT6fiXSmwtJCgkpFaJd2dR1vP9HSasVm1eNwGclmBPf9+t/dcVYMDqeB3l4XTpeR2zc3mzroK9lCCDE6bgxGLUsLUSqo+NJXPk9Pr4vZ2Vl2d3cZHx+XZQj+9E//NL/0S7/E+++/z+DgYNPjOsEnEycE6wVGLcG6efMmHR0dx061JDbS/JfBP6XtJQ+7t+pd2Rud2n2jTvYexmSP1ecN1puIijCHDKS36nyzxpzs3o+hd2t5yxDjwWqK1g4bm2uJBuG2yayltcPG3FRjdcBk1RLss5JM57HbDTy4v61o5njhYojHj3ZlGhuDUcPQkBedTsgMHBw6fgrKaNRwetjHvbvbcsJUo40JBMxYrHpFsiJicEggHXaHgR2F/D2AS5dD3LurPDXX0mKlvdOO2azj3bdXmobwiq3Q2kVOnO4rFMpMTe4TCFjI5Z9nYOmXqmyDQ0cZi3VeTM/LDDSZtFy8FCKXK7G6ciizwxDh9Zqw10zW1ULwzDJRLJWFPLtjXLsvXgpz7261utjSYqWtw06ipg35PMNNMUx5azNJb5+LYrExQqetzUa+0Lz6YjZrmbjaSjpVYGbmoKnpphLRqzVW3Vg/xOe3HjtQ4PGasNv1kteUaLdRa4566pSVnd006VRzL7iLl0JsbCRpa7M3zUo87txZbRra2wXC/uRRjHRauaXX0mqlWCjLiKDZLGQH6vUaFuajhFusx1oxQPXciefLZtezuZ6ULC00GqECedy58/pMfOkrn6e3z83c3Bzb29uMj4/LMgR/7ud+jv/4H/8j7777LiMjI01f6wSfXJwQrBcYtQTrzp07BINB2trajt3m58N/hHfARuSRvJ2gRLCURO1Koc/WDiPJlbqQ50tutm/J3yNwyUV0M8V/j+2wFqneeY5dDnJfwc/KatPhC1pYmqu+ny9oomRFtiD7/Wa6e1ysrx1KVYXnLf46nYqx8yFSqYJUYaqvAIj+VUrtPBDic9raBTuEZhoPEFovT5/KLSFq3eBnpg64eCn8XKI3OOTlwf0dXC4jvX1HhGlqX9IhBQJmSRjdDCNnfRj0GtQalcyrqxaXLoe5e6exFarRqOgf8GB36DEaNLz3bvNxd6NRRTBkZHmpWgHt6hJ0Wwf7GWZnI7S12SiWKpL/kBLOnPUxPxfFZjdw6pSyWP15rVCX28C5sSDxeE7RpRya2zmIETpGo5Z0usDGRqIpaQIhb/HJo10KhbIsELtWcP48sbrBoGZgyEsskhWqarEs03U5eoGAGb1B27Tt7fOZ6OmzEjlIsbyUbRoQrRTnU1uFnJuL0D/g4dYxxNRi0RJusTA3G0erFQxObVYDe7t5treFz7+1zUohXz62Gnp21E8uV8LlMrC3l1FsvR73Wbe2Ca1Xi1nHe++uKprJgnDD8ft/+HkGhzwsLCywsbHB+Pg4FotFes4v/MIv8NM//dO8/fbbnDt3ruk+n+CTjROC9QKjXC5TKAiLxYMHD3C5XHR2dh67zW+9+g7ZaJ7shvwOXCkKRzn02cPmdfljxgE12Wn5Bdx3zsneg5jsseIA/Pr8HomM/Ln+kJnoQZaCQovOYtUxOOLh7o1tOgccrEcSimJuEf0Dbto7hApOM18dh8NAa5utoZXR0+vC7zezuZmgUoZCsXysN0+t4F2smBzGc7KW3PMcxrVaQbdVKJQpFstMPtsll6uLz3EZCAYsihobQYfkwWrVsrWVOtY2on5qTvTqcjiMEjn9ViwJRKuGziNLg4NIRkZCxbiZY/flfACjSUsqWVBsE4Eg/n70UCArtTCbNbS0GrDZrJgtej76oHmb2GgUCJJIgHU6NQMDHizWauBxIGDGaNI1iM9rMTDoZmszhc9vFvzJdhrPdX0VrR4tLVZOD3vZ3EgypWDYCULltru7cUJSyncsV4hGMuRypWO/mz29NtbXUmSzZek7YjBqWKzxCXtebqDgeRYmHs/hdBoVBfpWq47WNjvTTYxT/QEdLS1mSiU1T59Em1ZelaYFpSDvvGCncG4seOxNk1otENy7t7clXzWNRiUT2TudBr745c8xcsbPwsIC6+vrDeTqV37lV/iX//Jf8tZbb3HhwoWm7/fnhX//7/89X/rSl5iensZkMnHlyhV+5md+hv7+fuk52WyWH//xH+d3fud3yOVyfPu3fzu/+Iu/SCAQ+J++fy8yTgjWC4xagvX48WMsFgvd3d3HbvP1H7rD7JfW0WsrVGou8Ga/kfSu/M7cc9rBwbPnhz7rO9TkV+RXTp1NSzFdpHJ0vUydVvFfH28zdNbJszriBTB+Jcjd681L+hPf1sLmQfJYw06ny0A4XLVYEAnTxnrVo6el1frcOJrTw17y+RJer6mpDUO9q3ot3G4jvf0u7HYDH7y32rR6YLXqONXllAmC9XoVg0NeDAYts7MRLBYdalXzgGNxf1dXDkmlChJhqhduX5oIc+eYsGWVCl55tY1CvtxAmETYbEILTUljI47ZVypClaKZxxhAR6eR3Z0CmaPKm8WiY2BQqJjMzkSIx3PPDYcWxd/37m5LbbWVlUMZ6RBbfvWTmLW4cDGIyaxjazPZ1Ix05IyPhflog01DMGSRfK+sVh03rh9PVi5cDElTrHa7kN9X6yZvswlk5bjw4bY2G5WKUF01m6sksRZ9/TaWl5Lk8407o1IJv4tTXU4WF6LM11SHj9tfES0tVtrb7SRTBdbWDgkELE0rvACtrVYymQIHBzksVg2trUa0Gi3LyylSqW/diuHqy60kk3mMBi3LS43VZpUKxi8o69VEkX04bOX/9c8nGD0XYGlpiZWVFcbHx2XWNr/2a7/GP/tn/4w//dM/5cqVK033588Tn/nMZ/h7f+/vceHCBYrFIv/8n/9znj59yuTkpET8fviHf5ivfe1r/Nqv/RoOh4Mf+ZEfQa1Wc+3atb+QfXxRcUKwXmDUEqzJyUk0Go3srkcJt352mmv/ZhJPl4nkmvwipTVrKNboJ5T8rNwDdiLT8sVTrVeh0qgo1VWm3IM2YvNJFrvy/OFT4SLs9ZtIHOYVNRbD5xw8fdBYRTjzkp8Pb6xRqcDAoAebTc/jRzsy4lIbxqyE9g47vb0uIpEMD44RMCsJ3kXykMkWmZ7c4/z4c9p5Jg2Dg0I7z2wWqgcajVoiDwB+vwmrTVlkLmJgwI3RpMVk0jaQBxHjF4M8frirWAESK0wmk4a3325uw2AwCEaZtYJgMX8vmxWEyHa7AcdzqlI9vU4ikSy5bKmBMIk4Px7k8aPGqpQIrVbNa6+3kUoVm5qM6nQqzpxV1tic6nIQClpJJHJkMkXmj9nfrm4n8XjVTV6smNROnD3PKwuEabZHj3YF3yu1mrnZCLGayUGNRsW5seZTiVqtmtFzfhwOA9PTB4rHDIITfzJRaKjgdnU5CQYtHBykQV1kcT7Z1FsN5G02UaCfO/qcc7nyc8X1IBDEjk4Her1GaCXWHTMIv8lMpqgY0K3RqGhrM+ANmNjZKrC22rwap1RV7e4W9GaRiGDc+7z9tdn0/O7vf5ax8SDLy8ssLy9z/vx5bDab9JwvfOEL/PiP/zhf+9rXeOWVV5q+1v9s7O3t4ff7ef/993nllVeIx+P4fD5++7d/m7/zd/4OANPT0wwODnLjxg0uX778l7avn3ScEKwXGJVKhXxeIEAzMzOUSiWGhoaO3Wb2Kxt89R/couWCk/2H8jt2pfgavV1L/rB6567SqMBQoVJ3zfSedbD/SE6OPJcdfG1jk5uL8tc8Lqi577SJuckMlYrQPusZd3PzdqP+w27XMzjkJZUSjn9tVTmMWcT4hSBPHgvGn36/QB5SqQKTz/alKtTzdFt6vZpzY0GKRcHAcvoovLcWbo8Rr9esGFSr1aoZGHDj9prZ200dW6kQReaZTPXcd3U5CYSq3lPPmyYUfaVu39o6Mjd1NriMC2amtmONVXt6XXh9ZkrFkqL1BMDwiI+lpVjD1JxGI/gS2e16tDo11z7caFqVAhg6bWXyWfX70nnKQTBoZnMzxupKBrNZS7eCsWctAkELer2GTLpAd4+LXK5KHkQMDLrZ3Eg2nUIzm7VcfbmVw3iemZmDpgJ7pcVf1Ko5HAa2thK4XCbJf0wJ9WJ1wU3eIquedvc4iRxkJW8vJQwO2dneztDd7aZUqjA1ddDgE3bcd9xk0jJ02oPbY+L+vZ2GnEURdrueQNAiq/hpNILeTGwlUqmQSjWSwVqcHnYzOxujkC/j9+vwB4xks7C4UB16eV5wuUolEFyxxT4zfSBVxkRYLDp+5/c/y4WLIVZWVlhcXOT8+fPY7XbpOV/84hf5J//kn/CVr3yFN954o+n7/UVgfn6e3t5enjx5wvDwMO+88w5vvPEG0WgUp9MpPa+jo4Mf/dEf5cd+7Mf+8nb2E44To9ETAELgcy7XnGCIcPcJd2waQ6NBqFEh9NkSMpM/rFasKqUKhrCK3Lx8kaw3HDWEdfzu+jozG40X2JlnEexOg+RlVYvZZxk6e2xUKBIv5xTJFcDhYZ5bNze5eCnM6kqcgUEPqZRylMyVq8IiKBKR3d20NO7vcBiEqphDLzPSrIfo8C76EYFAuM6c9WEy6ViYj2Kx6CgUy4rkChCImVrF/XvbJBN5TnXZMZlKxOMVNtarjLVZ+3FxMcbiYkxq5+XyJU4P+5ia3G94rsmspa/PLbV49nbT7B0ds9Wm58xZN1qdmsN49lhy1dfnZn8/LQmOtVo1wyNerDa95Oh+/oIg7FaqopVKFZ493RcMId9flypM+0dCdxFCfp5fMlEVUWsGe+qUnfZOB7FoDoNBrdh67eiwk80WpRawuMCbzVrGzvvQaNWUy2Wmnik7s4s4c9bPN7+xTKUikAcxaHmjZlrt8oRyJbNUqjD5bF9yeT84yDBxJUw8llMWq+s1ErkCWFmOS1ont9vI6FiATLqgOIUpYui0nZnpQ0oluBsRzqHBqGH0nB+jUcviQpTuHvexNxCFQglQ8daby5LRqtcreFctHFVanU4DXoVhgFKpGvLc0WHHaNISDlsJha1MTe43CM7FtqCou9zdLbC7K5Bzs0VNa6sRj9vM06fNiTQIbeJrH1WPSdAI+rBYdKyuHBKNZfnC73wXFy6GWFtbY3FxkbGxMRm5+sM//EP+8T/+x3zpS1/6SydX5XKZH/3RH+Xq1asMDw8DsL29jV6vl5ErgEAgwPZ2c1nFCf7P44RgnQD41pzcAVzdVqGdpzBho9apGx4zOBvDo40mIznkxClZQ6S0vTp+eXmLWLrEhSsh7lyXV6sOYzl6BlwUiyXSycZFLpsvk9aU8fkcqDV6FheUxce101jbR2PzTpdBcmSfnTlgeMR/rBlhpVIhmRTImtGo5dxYAK1OzdxMteXR0mpFrVI1EJFax+3Tw15UahU2qx6NWlkzdeFiiIcP/v/svXd4XIWZ/f+ZXjW9qPduy0XuNmC6gRhbQLIkYbNpG7IJYbMJ6ZtvNmTZEJJNI8kSUiCEJISAC9gGh24I7r2oWJIlW73PqM2MZjTz++PqXs1oivzbTSDgOc+TJ8+DRnfuHY3nnjnvec/pk8Zjbedmiatokjfq1bzySntSM7BGI2dhjSumsFb084Qj0Fg/iFanxG7XJfWrjY9NMTQ0iW8yxPCwn5pFTvQGFe1zNinFDb5oIhIKhTl9atbTdPU1Bfj9IfILTAn9PKJRWryxt53zSmTCOaMkBvwhZDJZHLmKhsWiwB+YYs/M5qJImJRKYfTq8QQoLbMyPORjOMFm5ORkiKNH+qRi7aJiMxarls4Lo3F/q7kqTzR5AKG6p6zcRlfnGHI5Cf9Wop9KVNrEcFRxAzQUCuP1BpicCKb012VmGjiwv5uJ8SAajYLFS1xodcqYv9WChSYa6kfjziPgn5bM/WvW5TDQPznz/xNxfyuVSsbCmtmeSTF9/2zTzHlkGSgrsyKTy9ifYjxeUGhmfDy2/zG6yLv57DD5BSaampJ7riYnwmRkGNi3bwCFQvDsmUwahgaDdHfPvj9Xrc6O+cIDwr9J8TXX6ZT84U+bWLM2h87OTlpaWli6dClms1l6/K5du/jEJz7BH//4RzZs2JD0ut4q3HXXXZw+fZq//OUvb/eppEF6RHjJQ1StOjo66O3tvaitl0eW/BmFRs54S6yXyr3cRt/hWPUlc5Wd3rlJ7S4Nk/3x6pMhR8uIJcgvTnUTmvnsNFs1hILhhIGLlQvttLV4YvxYpTVWmjtHYsZ95RU2rDYt9acHGBsLolJBQaGOlubk4weTSU1JqRW5XJZ0nJedbUSlkicsAxZHW84Zk3wyAzTEjh9F5BeYyM3JYHDIx9mm4XnHj0qljKW1mRw62DMbwzA1LYx5Zl6fRN2Ec1FYZMbl1iMDWlo8Ccc80SXUc1FWbsXh0KNUyti/rzupVwrix2Niie7EhDCGlMlg8ZLUiehms4asLAMdnWMz0QDEjSFz8zIITk0nXfFXKGRcvj6PUChMe5snxtwfjWRbfmKKvcfjx2LVzhvvUbNoNsBS2u6bns3MElWeZAnvIKg8oekwdrtOiNZIEBOysEYw10ePiaNRWmrB7pDR1eWjsyP56DDRGNPt1lNUbGHSF+JcyzClZbaUUSNWmxarRcu5cx6pZ1GplMds6BUWCRVGqWIslix1EQyGMZk0CbcSIXXmlsOpIjNTyE47sH+AZN8ptVoFj/3uZtZflU9XVxdNTU0sXboUq9UqPebPf/4z//iP/8hvf/tbbrvttqTn/FbhM5/5jFTHU1RUJP339Ijw7UOaYF3iEAlWT08P58+fvyjD4/Z/2EvXviGYjPWfmIsNeM/FbiQpzDKmvfFvMVOhjtH22Zu3TCGjf2mY3++L/5BeuS6Lg0k8V0VlFohEaGvxsnCNkwNHk9/UNRoFtcvc6HRK9u/rTjriyc42olIrYj68xcJXrVZBc/MITqeegf7JhGqHiNrlmZyZya8qLbPidOnp6R6PyZm6GB/UmrU5hELhGc9X/E0h0TahCDFJXqNV4BkJpPRtlZUL4yjxBhedwyTGMNQumzFtzxPkuH9fF9nZQnmvdzRAY/3s6FUuhxUr49WDaLjcesEjNz6VkNzCTG6XTtiEi4ZSKSMnV4PVpoeIkgvnR1P+nUrL9Fw475dGlIniI+aLy5DJYOXqbJqbhiktsxIKhqmPyhgDsUzZlrTAWKNRsHRZJjqtgjOnB+jvT/wFoLjEgsfjjyMi4ntsoG8CY4aahoahlH+nhTUmTp8Svhy4XAJhmlsJM1+4qqiIRiIRIbm/eSTuvGx2QUFKlK8mvscys/QMDfpTeuMSbQsKtUEmxsaEgNPlK7JSni9A7TI7R48ModfLyc3ToVIpuXBhkrHR4Mw1KXj08fdw9TWF9PT00NDQwJIlS7DZbNIxXnnlFd7//vfzq1/9ive///0pn+9vjUgkwt133822bdt47bXX4up4RJP7E088IRHBpqYmKisr0yb3vzHSBOsSx9TUFJFIhP7+fpqbm1m3bt28v7Pn66c48mAzpkwVgagtQYVGLhQ6z3lHKd0yQn2x/zFztY3e/cLNS2lQcNA5zolBHwF/OM5Yq9MrycwxxgSGxhxfJWPVdTnsO9SV8ttvQaGZqalperrHpUR2pVJOU+MgozMfrrm5GrzeEGNjyW9My5Zn4veHMJk0nG/3JvS2pCJOubkZ5BeY0OuVvPzS+aQ3bb1eSVm5LWZUp9cLuUzI5DTWD2I0qubdJiwusTA2NsXIsF/IvMpQSf4nEYuWuGg5O5zSV3TV1fkEAtMMDU7SlKTnMJmpOFqpUShkHDqYXJWyWDW4XAbJi6ZWCwn4Or2KttYR+vt9F9VxWD0TP+Fy6nFnGhgcnIxTEpevzOTY0b6EI28QNkBrl7npH/DRcGYgoW9LoZBRuywzbgtNoxW2QTUaOT3d4xgz1Cn9au5MAyqVnM6OMSkOweGMzcwqL7fR1x/fTxiN2mVu+nonyM0zzWyuxueELVxk4vTJxFEY4uaqw6Hj8OHepP+mtFoFZeVJegNtOnp7xhkdm8JoVKfMCCsqMuP1Bhge9seUS0d7ry4miuGyy3Px+UPIZYm3EgHWrMlmXwICJpdDbp4Gq1XLR/95AbfcWsPIyAj19fUsXrw4pqP1jTfe4L3vfS8/+9nP+Kd/+qek5/NW4dOf/jR/+MMfeOaZZ2K2wM1ms1Tb86lPfYrnnnuO3/zmN5hMJu6++24A9u7d+7ac86WCNMG6xCESrKGhIU6fPs369evn/Z3Tj7fzwl1HyVxsYqQ+9oPTVKBn9HzsqCJrrZ2eOeGi9oVmhk57UbtVPBMapKlX+BBPtiFosWrIMKvpaI/1m2h1CnIXmjh8pBetVsmSpS4G+iclU62ImkVO2tu8jI3Fb32pVHKqqu04nHoa6gfp6U5+005EnIpLhITx/t4J2to8rFyV+lu/Tq+kokIYqQi9fUKEQ8OZAWk7z+HQYbFqU46JysuFTjWAlpZ45UC87rY2L+MJrluoktGjUsrYu7c7YcWOdN1zRpROp57iUgs+n3DekQjSiDIZMjJU5OWbOdfqoarajkotj0uDz8wSNvguJBi7wuzWl0Ihp6NjNMbcHY2ltS7q6+MVHGm0NRnEYFClVKUAFi4yc/qk8Bw6nUA8VCoFzc3DjAz70WjkVC9wptzyEwijHpBhd+jo7R6P6zqcr0InM8vAgoUOvCMBjh/vS5oyvmJlFseOxtYliTlhCoWMs2eHyc1Vc/pUct+WXC5kQh080BOlYmro7p6QiNLF9AY6HDqyso0YDCpp7Dv3vIuKhaWDRNuNovcqI0NN/ZnBpD2SEJ8oP3crUSgvT71RqFTK+M/7l7FgoRKvV7jOrKwssrKysFqtyOVy9u3bxy233MIPf/hDPv7xjyc91lsJmdB0HodHH32Uj3zkI8Bs0OgTTzwREzSamZn5Fp7ppYc0wbrEIRIsr9fLkSNHuPrqq+f9ne4DQ/zxuj3krbPRfzCWOFmW6PEcn1MZs8DE8Jm52VdyFEVKHj3fw+DYrGqSYVIjg4Tr7w6XDkOGivOtM4ZfpxaVXRGzTSZC8ALpaD47QkmplSOHe1MTiBniJJOJJbaamOwomQwqKvU0NiT/kNfplSxeIpRlz01kF2F36LDZtAk9WQajiqoqO2q1nN6eyYT9eiLEcFCRMM6W72q4cGGUrs7xOFN8Iqxdl8PeN7tmq3e8fhobhuaM87I4sD85cXI6dVQvdDAxHkw6znM4dJjM8UpbdBr85GSQnu7xlDfShTUO2tpmS5BFc//Q4DgtzaNEIkI33tEjiTsZRaxZl8OpkwNUVNqQR4V1zp6XQNKOHE7sK5LLZdQscuBw6jnbOJzUaO506tAb4hWcnBwj+QWC5yjgDzHiCSSNNQCBKLc0C34qY4aaikohZPRs1HmvXJ3F4YO9KWMsFtZkMD4+TWamhZ7u8Tj/YHSaeSLk5BgpKjKjVCt4Y09H0tR5l0uHRquKCeQVz1sug7NNI9gdOkaGU0dHiMrVdChMRaXwPunuGos571VrsjmYIlEe4MqrBPVVHCXOJXpKpZyHfrmBmzeV0d/fz8mTJ8nNzSUQCPDLX/6SHTt2UFNTw/79+7n//vv57Gc/m/zJ0khjBmmCdYkjGAwSDocZHx9n7969XH/99fP+jm94iocKdyYsfdYUyQi0xb6l5GoZcqWM0OTsDS9creSFaQ+Np+O/safKuVKq5Cxd6WZgaIIe7yR9fcnVJhAIhNcbICNDTXPzSNxNTKGQsXxFVlI/UHGJhaxsI0qFjD2vJe/OS6Q42exaysqs+P3TNNQPkpWdwVQgRM88Y63OC6P4/SHKK6yEQj56e4J4ogqxl68QwjYTxRqIuPqafHz+6YQbXzC7nZdIaZM21YLTyBXylCZzq03oWxTHeSqVMM7TG2bHeRfTGVhZZaenexyrVUt2tlEy90ejdpmbM6eTh3aazWpWrs5haGiShvohfEnGnYnGROJ5GwwqurrGcDr1McGpc2EwyHG59bTNZLSJRveREb+UPZWdbUQmg64UlTRl5VZ8vhBZWUbC4QiNDYNxOUxLat00JAkrFQuLc3KEBoJkQbkACxZmcOZ07M/z8jLIzTPh9fppaR6mZlHqkuPoahtx+xSEjUGR6LndelRqBZ0pthvLyq3o9Sr0elVMB2g0Uo0FBe9VBhqtkjff6EgZjDq3u3HuVuLY2BQ/+/kG6m4tZ2BggJMnT1JTU4PLJXxZ8vl8PPTQQ3zrW9/CaDQSCAS49tpr2bhxI3V1dTidzqTPncaljTTBusQhEiy/389rr73Ghg0bkkrO0XioeBemPB2e07FKjEwFMrmM8Jw+PKlbUAZDVREeP9GP3aVjPEEqu1wuY9EyJ8cPJVYPKmtt9I/5cDr1HD/Wm9AXo9UJHqvom2S0ytPePsr4WIDCosTmcBEul44Mk5BALhpqPR5B5RH/5bjdKkIhGUNDiUMnAZbWulGp5ITDERrq42+ikDxVXTpvqxa1Ss7rezrm7X+LJk5iJcvYmOBrUanik9fnwmLRkJlp4Pz5Uaqq45PkQSAQCkXyGh6ZDNZeloNCLuf8eW/S+pvFS1ycbRqO23aTwk19IfQ6BQcPpFZnom+kmpkOQa1GSUuLQKyTeaWiIQaRTk4GcbkNCQmq3a7DYFRw4Xxi4mSza1m02EVwapojh3ulLc65qK62c6FjLGZ8K/jNHOj1StrOecjNN3HiWP886uvs6KuwyExWloHhYX9MBc3cANa5EMrLMwmHYTocoSkB0TOZ1GRmGZOH4FYJCxFebyCpkR+ExP7BQV9M+Gpevonc3AxpIWJhjZOmpuGUJv1Vq4UxZkbGbG3Q3PfofN2YKpWcn/38ejbVlTM0NMSJEydYsGBBTEffqVOnuOmmm/jKV77CF77wBc6cOcOOHTvYuXMnX/7yl9m0aVPS46dxaSNNsC5xiAQrGAzy8ssvc+2116JUzh+P9uQNexg8Mwr+IMy56TkWmRk8GTsSyVxtZ+D4CKdyfLzQ6JH+ezK1SqmUUbXIwamjsR/Ui9a5+MuBTulGa7Vqqayy0dszIflaUo3hRGRlG8nONqJWK+JGDiJKSi2MjU4lHFmJ3imVSs7p0wNJk7ohvj5n7kbi8JB/3m3CaOIk3ESNDAxMxihmiSpr5iI3L0MwvY9O0TBny01EMh+UeBM1GtX4fEG6OsdTJm3XLHJyrtXDxERQeu68PBNej5+GGYKayDM0F2vW5nDq1MDMWAyaGoYYG5tV9FKpcSAQ1OoFdjKzDDQ3jST8W4MQ+ZCZFd+NFx0fIY6zUqkzuXlaxsfCeDxTUb4teYxPbtFiJ81nk0cogDDqHBnx43DoZv7WnvjXJkV8h92ho7jYRDji49SJsYTdgiC8byqrHZyIilkQFwv0ehVt5zz4/dM4XamjI7KyhU6+nu5xCgvNZGUbYxQ9EMjVwIAvpUl/5eosiAj5YU2NiUfOK1dncehAT9y/FzEF32RWo9Eo2fNq8oonmQx++OC1vP+D1QwPD3P8+HGqqqrIysqSHtPQ0MANN9zAZz/7Wb7+9a8nPVYaaSRCmmBd4giFQkxPTxMOh3nhhRe48sor0Wq18/7ea189ydGftaAvhOmuORuCq6z0Hoj9IDaUatkx3s/JjtgbssmiITwdZnws/kNUrVGweJmLI/t7kMlkVK628+a+5N9Gi0ss5OVnMDToiwmznIvyChtDQ76YcaGYOzUwKHSTLV7ioqV5RCIHibBylUAOtFrhJjodjtBwZkAqIQZYsNDImdPJlQOlUsblV+Th94eS9gWmIk5SYbAvxHRomjOnU2+pabVKyQ+k1QoRDirVbNimSL4S9b/NXpOD8+dHyXQbcLr09PaOx5nN5xtj2uxali/PYmBgkvok23mQWIFQqeTkF+rQaGSMDEfIyclIOcY0GJQUFs0ashON8xwOHRlRdTOJkJ9vQqEQjOoATY2xRA+ExYOurrGECqWoRObkZtB2zpOylzGRryia6DU2DLJiRXbM6Cv++aCswkBTw0TM37q1dTbfTKudiY5IoeJarBrhy4RaIdUszUV2tpFIJJJw/G2zaSkts6JWK2g+O5w0jwzix4IqlZzKSjuGDBUX2kfp7h5n5aosDh9KrWaKxHOuMiZ6C2Uy+N4PruYf/2khIyMjHDt2jMrKSrKzs6VjNDc3c8MNN/CJT3yCb33rW0mfK400kiFNsC5xiAQL4IUXXmDdunVSA3sqvPnbIxz4zHkMC2SEzsbeHI15OsajiJS6QM3vBvuwFRk5fSx+vLB8TSaH9yW/QVYvcaCxK3g1xbdREKIGWltGmBgPSoGXc/0dYhK3359cOVh/pVAjMzYqjNQSJW0nUw7E+AeVWo5aJecvb1xcqbOIrCwN+QVWBgf9tLZ4sFg0M3UhyYlTVrYRtUqOdzRAebmNYDBMQ/1gzGhKjGoYSGIgVyhkXHFlHsFgmJbmkaTxB8uWZ3L61ECcH0g0m496A5hMag7sj1cXohFNnBIVWl/MOE+nU1BeYWdyMojDqae3J57oWawanAmqWUTY7FpqFjmZno5w6EB3UqJXWiZ0+UXnaalUcqqq7OhmUuxdbgOtLSMpoy4W1lhobPASCkVmbv5GvJ6ApOjNfW2SYd3lufh9IWTyWKO7CIUCSkr1nG2K/3tH19ggk6WseLLZtVjM2piFC7GLc9InREA4XXqmpyMpIzNKy6wM9E/i94eE0a1WSXtbfPL/fFEMYlTI8ExGWaL3WLJ/m2az0NIQAd77vgo+8rFFeDwejh49SkVFBTk5OdJjz507xw033MAdd9zBd77znYuyTaSRxlykCdYljmiC9fLLL7N8+fKYKohE2LdvHyODHpo+5iMjV0fgQvyHuCFby0S3H1mlioebupicipCVa2SgdyLhinmyUaEzW09IF6atzcuChQ5UKjknT/THkZ5k/XswW3KsVit4/bULF33jh1nD91QwTMOZAcLhCEuWzu/jKSu3cfrUgNBTaFLT1hp7MzEa5djtWs6fT/1t3mrTMtA/mXAjEYQx5qg3XnESA0YVCjnToWnONnsSRjWImEucxAiHvr4JafNv9ZpsDh7oSa0crM2hsWFISJJPQPTkcli+MouDSbYSxa5Ch1PH6VODSW/aJpOa7GwjjXPGecI2pAnv6BTDQz40akXSkSAI2WiTk0EG+iclohddnwNQVW2ns2MsYcSHiNpaN+MTQex2Lf39kwnVqaXLHJw4lpiwiyqP2azhjTc6Eo5uRaxak82BqHGoWAKeMZPLNjAwMdNUkPy9ZTAoKSg0U39mSPIWjo4GaGwYkv4N2R06MozquCDXaJSWWrE7tIQj0NIcG7khorzcRm9v4mJs4X2mE6qOjvSm9FytWJnFkcOzypXNrqW0VKgNamgQlhouhpz+13fW8/FPLMbr9XL06FHKysrIzc2Vfn7hwgWuv/56br31Vn74wx+myVUa/2ukCdYljmiCtWfPHmpqamISi+fixRdflB4//gsDF14eIMOpZGokdlTiXmmlZWKER070xRCDVGrVXJJVVGXmwuAYQ0OxY0WXS09pqZXunjHOt4/OlOYmz7eJ3hQUt6aGo1K6QRiVLFjoTLlB5c40UFFpY3IySGN9Ym+I0ynEESS6wZaVC8GRE+MCIUqVt1VWbmV42C+Ncmw2LWXlNgKBEPVnhODImkVOzp3zJKwRErF8RSb1ZwYpLrFiNAp+mrkjmvmIU25uhrDd2DGalOglS2ePJnrn2z3k5JpSZkYJdT4ZUiBnSakFlzSGFIiS06nDmJF6nJeXJ2yYWa1apqfD1NfH+83Kyq0MDEwm9M+JXp6sTAOt5zwJU8hFJPKRZWUZKCi0MD4uqKArV2WlfI8C1C5zcPTIYFRAqUIy6ENsPlUyqNVySst0qNVqJifgbALlLiNDRU5ORhw5BUHlKSu3olDIGBnxczZJoCwIr7E/MC2potHJ/6KvsbzCJgSOJiBXIhYtFgztFrNGqt+ZG466YmUmRw73JX2PajQKrrgyj9HRqYS1QSLuve9yPvmppRK5KikpIT8/X/p5V1cX119/PTfeeCM/+9nP0uQqjf8T0gTrEsf09DShkDDS+Mtf/kJFRUXCtWNxyxCEYLvrrruOow+18PpXT5O9yszQUY/0WLlKxoUFQZ4+FD/Wsjl1TI5PJf2GvnCJg/6eSRwFeo6cTv2NVqdXUlvrJhIRTMcXLsQrFUajiuISS8KtJpdLT1GJhUAgSMAfnn8MF1Wfo1YLxmBdlFG9qEjwQiULiwQhjqC3dxyTSUNmpp6urhG6OmNv8KXlRro6fDFermgYjCrWrcvF4/FTf2YwIdGD5PUuZeWCOtXdPU52lnFeH0+04iQqLaKiFwiELypsMyNDRUGhhUgkQoZJHZckD4JiYk6QlSXC6dJQvcDFVGCaA/u7kxZal5ZZGB6OrZIRPUhqtdB/l5VlpL3dm5Kc1i5zc/rUAFNTYYqKzWRlGhmYkwa/ak02h+ZR9S6/Ihe/f5pwJEJjkg3SJUttHE8wPpfJoKLChs2hQ6WUp4wK0WoVZGWpaGubvW6nc6YQOxCioX4QrVaFy518ZApCzIJaraC3d4IqMXKjzRvzvi4oMDE5GUrp1Vu1OgulUsGIxx/jf4pGsrHgrJqoQKGEA/vmU05jv2RJtUFRnrGv/8c6PvOvyxgbG+Pw4cMUFxdTUFAg/U5PTw833HAD69ev5xe/+AVyeXx5fRpp/P9BmmBd4ogmWPv27aOwsDBmiwbA4/Gwf/9+ALRaLVdccQWhUIjhllH+sPp1slZZGT46k4NkVvKa0cOh9gkWLHFw5ni82XzxchenjsaP+UQsWe9mKiwUFScaOYAQn2Ayx+ZOFRWbycwySknZ7kzDzLp7cvWhoMBEMBRmcjJIebkthjiImKsmzYVcLmP9lXkEQ6n9S8l6/NxuPYXFFibGg+h0Mo4eGUga4AixY0xpI1GnpCUq52u+1GqFQsay5Zn0dI+Tm2diZMRHY0PsDV6rVVBV7UhKnPR6JYsWuzAY1Bw62J1UpUgWMlpSasHlNtDXO8HUVIhwmIQmf+nxJRY8XiGQ02zRUFFhIxQM09A4m3lVvcBOx4V5xnnL3QT802SY1HR2jCYsd165ShhHJfo7iB4kvUHFX17vSJlHNndkNXc7r79/khUrU6tSSqVwXSdPDM1uYs4JhNXpFbhcKs63Jw/tzMo2UFxsIRgMc/bscELlLjPLgEIuS5jdJaiJBgL+IOfPjzKUopaqotJGd9e49HcwWzSUl9sIRyI0zYTRXoznavnKTE4c66ek1CooY91jcXEf8/UlOl16/u3zy/n4J5YwNjbGkSNHKCgoiClE7uvr48Ybb2T16tU88sgjaXKVxl8FaYJ1iSOaYB06dIisrKwYP0JLSwstLS2AUBtRU1Mjpb/L5XJ+t/I1Ap4pIhNTaHLU/HG0j/MzeVBFZZak/YG1qzM5uj92HKdSyymutXLgoPBhqdUqWbTEyahXKPwVUVom+I5SV2dkSd/Ck31bX7DQQWfHWExuDsxWi8hkQq1i/enBlOv0cxPTS8usuFx6urvHaG8TbgZr1mZzYP/8/qX6+kGJOJyZEy4pk8GixVZOHE98PXK5jKpqO9k5RurPDNLVmZis6PRKyud0HIKgdpSUCjUyQtimIeZ1nwunU0dGhoZz5zwxAaPRI5rcPONFESelUo7VrmXUG4ghDiKqq+10JPFBieqUxaqhoX4opdk60ThPLHcWw01XrxU8Tim9ejNG6tl08vg0+Plu/EqljDXrcgiFIvT1TiRU7jQaOfkFBprPxsdCSP7AqSAezzjtbckJj82uxWzWSF82ohP0xUWQ7GwjEUgZCFtUJJR3KxXyGKN7NMmsrLLR2Tme1POnVsu5bGZz9lyrJ+nfa/mKmZ7IOSQ3NzeD3PwMxkanyMhQsX9fcnIKcM+XVvLFL69mfHycw4cPk5+fT3FxsfTzwcFBbrrpJhYtWsTjjz+OQqFIebw00rhYpAnWJQ4xAwvg6NGj2Gw2CgsLAdi/fz8ejweARYsWkZmZKZErpVKJXC7ntS+d5MQv29CvVvOLE12MzRlrLVnhShoYWrvKTdOZYSbGg5isajJyNJypTxyvIG5cAZw43p9yU2tprZvGhiGJFGVmGSgqsuD1+iUP0dxsqkRYvSab48f6qai0odUqOHs23sSbKocIIL8gg8pKO+3towkDGkG40dYuy4xTMWb9SzLaznnIzNZz+mTiY4AwDi0sMksRFaK5P7oseG7yeiK43XqsVi1Gk5pIGBrqB+Ne77y8DEKhcMK1fLGoODfPxGD/BKdSRGYkUpysVi0FRQZGvRN0dU5RVe2gsWE45eanSJzC4QiVVTZMZg0dM5VBIlavETxiqT7x1l+Zhz8wjW8yREP9QMKE8GTqYHSkgBAIm3w7T60WojdiNkizjRQWmBgbn6KhfgiNRkFxiSVl5EhGhpIMk5zBwRDV1aJvyxOjtjqdOvR6VUqz/9JaNxkZavr7J2Nyq6JRXGLBMxK7SQmzX0jkchlTUyFaWlL7AucqV6IyFl3GvWxFJscTkKtorFqdLSxUVFghkjg247OfW85Xv76WiYkJDh8+TG5uLiUlJdLPh4eH2bhxI6Wlpfzxj3+8qAzANNK4WKQJ1iWOaIJ18uRJDAYDJSUlvPTSS5KydeWVV6JSqQgGgzHkCqDl+S623X+U16e9NNfH32yz84yMDPnwTSYeAzjdegrLMmi4MJKy5gNmVaCiIjOuTAOdF+IrNuZTiuwOHcuWZ9LXO0H9mcQ3UJmMhMZ5hUImbAVmqLlwwUturinlaEejkbOwxiUZ5+12NS63CplMQ1PjCNPTEQwGJSUl1tQ5RBYNObkZKOQydAYVrc0jcQGfVqsak1nD+fbEr2F2jpHyCiuBQJj9e5MHmhYWmfBNhmJMwhqNYsa/JJiuHXY9AwOTKTvkxKys8bEpKYto7hhySa2bxvrUkRmr12QTDE4jl8cnyUc/JhlxKiwyk51lRKtT8srL55M+D8SP8wzGGeIwo06NjU2xclXqXkalUsbiJULdjOgDiia4MJM9VWHn5InEXzxAIFvl5VbGx4MJ63MATCYleoOc3p5YpUiMYbDZdYyO+vF6plIGo+blZRAITEuKsOizCwXD1M+E0ZaUWBga9qUM1K2qttPVOUZObgYWizZhBc58Y0GnS8/SpS4GB3ycSZGPNrfcGQSCW1Fpx2hUceHCKHW3lvONb17G5OQkhw8fJisri9LSUsm47vV62bhxI7m5uTz99NOoVKqk15ZGGv8bpAnWJY5ognXmzBkUCgXt7e3Sz2+44QaCwSDT09Nx5GpiYoJDh47y9X9pYah/ioJiM+2t8X6n6kV2mhtHCCZQi8oW2Wi6MIQ700BGhprjx/rixkNyOaxclXjcIqo0vd1juDONKUcyKpWMpbWzSlFGhloICI3aMtNqFVQvcKRMQxeN8z5fCIdDT1dnvMF+vvwqs0XDosVOFHI5+/Z2Jr2RZGcbUarkManqQvG0HatNS8d5LzIZ+HxBBgeT3/xKyyyMjAj+JXEj0R8I0XBmdrxTVW2nu2s8IYkRsXiJi+lwGKNRzYUkwaipOgMdDh0lpVb0BiX73uxKWiMD8cRJIrhRJnmxrDoVROLkduspKrYwMRGkoX628FcmE95fyfooQSBFq9fk4PeHEm5iQuJEdBHiVuHkpKAAnzqZXJUymzUxRvTZ5H8lbeeEfkebXYNKGaGvL7nXzJ2pQy5XoJDLyMvPwJtg/DqfWV2jVbB6TTbToQgNDUNJfYjV1XbOXxiNU64KCkxk52Tg9fhRqRU0NAyl9FzVLhfqokKhcExsRnQKfrIU92jc+S9L+NZ/XYHP5+Pw4cO43W7KysokcjU2NsbmzZux2Wxs27YNjUaT/GBppPG/RJpgXeKIRCJMTQkf0idOnKCnRyAfGo2G9evXSzEOcrlc+h8I0vqJEyfIzc3l5IFp/v3uPSxc6uT0scRKTE2tk4aTsS32NWud7DvcHeOHcbr0lJVa6Zj59mswKCkti/cLRUN8zPCwn7zcjLhNLxDW//PyTVKa91zodEqW1rrRapUcOtgdN2oQ4XbrMRjVcX6ZgkITOdkZ9A9M4PNNI5fL6Eiw1Sg9vsBEYGqa3p4J9HolVdUO5HIZjQ2D0nOXllnwjARS1tFUVduJRISxWn//RMJ4iIoqC50XJhKm0ovjHbNJzfET/TGbd3Mx12sG8WPIVWuyOZwkj0yEuN1oMKqprBQiQRobYmMv5hu9Alw5EzqZzL8kEKfEilPGjHcqEhGUj1TEXKORU1Xt5PixWdIt5oSJKfZ6vXLecZ7JpCYr20hvzwTlFbaE5c5WmxarVZt0k1Lw4dkJh/14PDI6LiT2S7ncGoLBaUaGY5Uv0Ww+PR1mYiLI4KAvKWkCYcGjv28Srzcwq4zZdPT0zPoLqxfYOd8+mrL1YNFiJ329E+QXmJmens2tikbtMjcnTwwkrE0SIyDy8jNobR7hXIrFlY/98yK+/cCVErlyOp1UVFRI5GpiYoJbbrkFrVbLzp07L6q5Io00/jdIE6xLHCLBamtro6mpCQC3283ixYulnkK5XB7jTejs7KSpqYnKykpycnKYng6z+bKnaWkcoaLaRlN9Yn9PSYWF4FSYjvOjLFjr5C97k3tUAJatcGMyaak/PZA01yYZ4RF8V2a83gBer2DKTRk4ObNN2N01LiR0VzvQ6ZQxOUQlM2noqcz15RU2IpEIDoeOkREfTY0jcd+0qxfY6epMrBSJz223a2luHk644SYi0VZiVraRwkITXm+AhvohFtZYaaj3JAx3FbFqdTaHD/WgUMik626O2kiE5JEP0Vh/VR5TgWnpuROmbCfxLylVMgoKdFhtGeh1qpT+pUR5UNk5RvJnkuQbG4ZQKGQsWuxOmWum1SqoqLLTWD9ERZVd+HvPuW6BOFk5fSp1eXFenom+/smkcQQWqwaHI77LT6NRSMnmQ0OTBIMRKQokEVxuHaFQkOEhgZzkiNcd1TqQn2/C7w+lfJ8WFZuYnAiRmWVEp1PS2jLCwEAs0UoVECo+d1W1naEhPyeOxyvPIhKNBTUaBZXVQhn3udYR8vJNScmViOgsrGije3Q46j99pIbvfv8q/H4/hw8fxm63U1lZKZErn8/He9/7XgB27dqFXq9P+nxppPF/RZpgXeKIRCL85S9/YXhYIEVGo5G1a9dK5EqhUEhbNZFIhLNnz9LT08PixYuxWq3ScV7c2cbdH3qBwhIzg/2TCbsFAYxmNQvWODh4uCdpBAMI35xHhv0MDvqkLCCLTRuTn1RaZsHrTV7/AsK6+FRgGpfbgM8XpP7MYBzZqF7ooCvBNiHM9scJuUkeziUYgYpYWuuisWE4ZuPQbFFRWenA55umoX6AxUvcnDoZXzUTjZWrsjh6RLiRVFTaMFs0Ug+biIvJX7riyjwC/umYcNK451qdycH98SREvG6LVYtGo+C1V1LXFK1eI5RVi7DZtJSWW5kKTNNQP0gwGE4YRBoNpVIY4R453CsEVtq0cT47tVrOwprUhdaZmQaqFtjxjATikuRFzO0nFCG+16w2HYODk8jlsrjy52hYbVpsNq2kHFqsGsrKbDFjZ6dTh96gTkmc3JkG1Go5Op0Ku0MnBHXOiSPIzNIT8E8xMpLYs2a2aKhdlslUIMSxo31JF0FycrV4PFNMjM++H2QyKCsX6nO6u8fRaBQxMQuJUL3QQfs5D5OTodkYhjmq3MVEMdQuczMxEcRm08U0B0Rj+cpMjh1JbHoXw1FXrMjiG9+6jKmpKQ4fPozVaqWqqkoiV36/n9tvvx2fz8fu3bsxGo1JzymNNP4aSBOsSxwnTpyQPFclJSV4PB5qamri/FahUIhTp07h8/lYsmRJwm9+H79tF2++0kl5tY2Odm+csd3m1iG3yGhpHkGrVbJkqYu+vom4nKraZW4a6oeSRiOUlVvJzzdx/vxowuLZ6OPM7R00mdRUVNqZDgk3wJpFrnm3CVeuzuLoYWG1X+g41NHdNR6jiKWq6hFx2RW5+P1C3lND/WDciARI6SkSc6O0Wjmvvpw8cBLilSLRsC1jditwwUIzp08lv+mLWVkHD/RIGWMD/RO0REVvKJUyltS6OXwwuVJksWhYWutmfDwYF2UgQqtVUFFpTzgKLiw0k5VtxDPiQ6GUz7NVpyIv3yQlwUcnyYsmeYtFg8ttSLlJabNrsVi0hEJhcnIy4pL/gXmJk1arZNmKTFRKOSdO9Cf9QpGTa0zY5RedeTU66mNsNIDXm5yoRG/5RStErS2zSxFiJ2Aqn11llZ3g1DROtz5OIRKxYKGDc62ehP9Gxawvu1NHc2Pq5ZWltS5OnxqMGTuLfrWJ8SkaGgZZvNQ970bhP7y/ih/95FqCwSmOHDmCyWRiwYIFErmamprigx/8IENDQ7z44ouYTKakx0ojjb8W0gQrDf785z9z5ZVX0tnZSUtLC+Xl5djtdmks6PP5OH78OGq1mkWLFiXdtpkYD/KxW3dy4lA/VYvsdLWPSTfT/HITPaMTCdUmwdehpalpmIpKOwf2Jd9yA1i9NpuDM5uCUrjonKLfNWsFRSXVcS67PBefL4hMLqPhTOJNrVTdZgWFZrKzDej0Sl55KbnCI2wlxh5HLIVWKuU0NQ4xPj7FilWxHXNzEU14xJvv3Bu/SiWbtysxI0PFsuVZ+Hwhms8Ox63dg+g7cnA8kWF7Zgw5NjaFQiFP6Y8zGlUUFJolpUjMy9LpFJxtGsTjCWEyqcnJzUiZpC+SIq/HT2GxhckJQY2Mvuna7FpsNl1S0i2+fgajKmVeltutR6NVxiwWwKxB3+8P4RnxEQpFEgZyisjNMxIKCcQpUe4UzJjMfaGUKmxevoGpqSA5OWYiEXlCVa60zMLAgA+vJ544iepUbq6Rnt4JGs4kf53zC7T0903h988SHsm3FY7Q1DBIUbGF1pbE5EqEWH8T8E8n3aZMRK7mYs2abIKhMLIEOWMibntvBT956HpCoSBHjhzBaDSycOFCiVwFg0H+6Z/+ic7OTl566aUY5T2NNP6WSBOsNPD7/QSDQQKBAG1tbQwODhKJRHA6nRiNRtra2nC73VRUVMybcDzqDfCRzTupPzGIzakjN99IkDAnmlJnVykUMlaszGJiIohOp6SpMX4lX9gmjB1FRSMvTyit1WoVvPJycsIT3U0oQvTCaLQKzjYNMz42xdLa1ERFrZazaLGLw4d6ycoy4HKrGRnx0XHBLxG7uVENiWA0qli2PJNAYDqhFwaSh4OCsBhQUmJhcjKEXAbHUxCejAwV+QWzhEe48dsxm9W0zYxfjUYFNruKC+eTj3BFwjM4MCmNAueOIa02LXZ7csIjk8GSpW4sVg2tzZ6EVUcgpPbr9fGlw5IaOR1mcNBHJELKxYKsbCMKuUxSVKQbf+8ErTNjqdw8I9OhSMJ8LxH5+SZkMrA79SjkiW/8BYVmJieCSbfzCgpNlJRY8Yz4OZqiYqig0MjgoI+J8VlCJQarqtRyms+OCGb7efr+KqvsdHaOMT42NVPuHL9VGD3yS4bFS1zIZKDRKmlrFTYa5yLVWDAzy0BBoRmNRsHhgz0pn2uu6V2plFNZZSMjQ835mQ3WzbeU8T8PbyAcnubw4cMYDAYWLlwYo7x//OMf5+zZs7zyyivY7fakz5dGGn9tpAnWJY7R0VGGh4exWCzSlqBMJsPj8dDW1sbQ0BByuRy3243L5cJut8+bdBzwh/jpd47wyE9PsGCNk5FxgXAkMwpnZKgoLLJwKioLSqmUU73Ajk6noqlJWO0ur7DHbHLNhV6vpGyGhLgzhVqQ6HBRSN1NKMJi0bCgxkkoFOZcEsIjlBKbqD8TP66y2bWUldmYmgoRDIZTjrQsVg2ZboNUvBu9qXXhgpeuznFsdoGopOqPszt0WK1aBvonKa+wSSPQaKUjWWVNNGqXuTGbNbS3eWlLUnDsduvRapVxSwPRgZNDgz6Cwem4HKRoZGcbkUcRnoICEzk5GQwO+jh7Vng9cvOMTE+nThfPzxfGPTa7FrVGQXOCQNiCAhM+X3Ljd1a2kcpKO+MTUxw51JPUsF1cYsHjie05nJtin2FSMzToT5kTVlZupb9/Eq8nMEuQfSEaorLZioqN9PVOMjmZXOGpXuBAoZBhzFAnzIUTHpN8y89iFdQprVbB6VMDDA8nHx0WFmnp7pqSSLQYKOtw6qVNzovxXC1Z6qL+zCBqjVLYIpXJODuHpC6tFXogU6lb//SRhXz7gSuJRKY5cuQIOp2OmpoaiVxNT0/zL//yLxw/fpxXX30Vl8uV9Fh/bbz++ut873vf48iRI/T09LBt2zbq6uqkn3/kIx/hsccei/mdDRs2sHv37rfsHNP42yNNsC5x/OlPf+KOO+7giiuuoK6ujptvvhm73c6XvvQlnE4nH//4x1Gr1fT19dHf38/U1BQOhwO3243D4UhJthpOD/LAd/bz593niEQED5HTqefM6QEpiiAr24hGrYhTJ6KRmWWgsNAMQEuCkE0QVI4MkyZhTIHdoaO01Mr0dBiPxx/jIZoLd6YBnU5J+wy5SER4MrMMaDTKlKZlMb/KM+KXVBbR9Cw9JkdQVFKRkGXLM2e+sXuTdirm5WUQDsePq6KT4D0eP+NjwZTKTHR0BMx6gKIDQjOzNPh903g8yZWHwiITgUAYp1OPXh+/kQhCb+T4WHKFx+3Ws2Chg4mJEEcO9yTdgiwtszA8FJsurlDIqKgUVLnz7aPoDSqGBn0XTXhE0hEMhmPGceUVNvp6J+bxL9mQy2WYzVp6esal91HsY2bVpLkwZqipqLAhlwVpbvHiSWJoh8TEqaDQTE62kaGZ0fGChQ7a5lGlFtY4aG3xEI5EqKqyJ0yDr1nk5GzTcMrljHWX5RKORBjzBmhI4NsCQQFrbBiKO86sOqUhEolw9EhvSl/kDTcW88tHb0Qmi3DkyBHUajWLFy+WyFU4HOauu+5i//797Nmzh8zMzKTH+lvg+eef580332TZsmXceuutCQlWX18fjz76qPTfNBpNenz5LkOaYF3iiEQinDt3ji1btrB161YOHz6M2WwmGAzy6KOPcsMNN0hehkgkwtjYGP39/fT19eH3+3E4HLhcLpxOZ9KaicbGIX7z65NsfbqJ0dEpNFoFCxc60emED/JU3XFzoxFkMuEGZbFoaWsTfrek1MLYaOr4BHHjcCowTUWljeDUNPX1gzEBn6VlFryeqaQ3fRDM4yqVgo4Lo0kVntIyYfQzlwhKhEcuY9InkJ1UuVNl5VaGhnzSY8TRzsiIXyI85eU2BgcnE/qoRJRX2BgZ9pGZZUSvV8VET4ioqLTR1zeRNKnb6dRTs9jJ+NgUR4/0JiU8lVU2erpjSYhcLqOk1IRSGWRkJILFoqenO3WgaWWVne4uwcMXPQqMzk+qqrbTmaSfUET1AjvT0xFsdl2cByj6MefPx4dkwuzfzGhS09w4Qk9PciVtwUIH7W3eGMIjxiiI47iq6vjHzEVZuYkL58cJh0nY7wiwsMZJa8tISh/UqjXZQgjtZIiG+sRbpDWLnDSfHYlL04/epoxEIhw71hdXUh6NomItnR0BSX0T/2bR5c7JyFU0lix10VA/RHaOkaxMIwODPprPxi4XXHt9IY889h7k8ghHjx5FqVSyZMkSiVxFIhH+7d/+jVdffZU9e/aQk5OT9PneCshksoQEy+PxsH379rftvNL42yNNsNKQ0N3dzXve8x48Hg9Op5Njx46xYsUKNm3aRF1dHXl5eTFka2JiQlK2JiYmsNvtuN1unE5nQiO8zxdi93OtbHm6iVFvgBMn+lGpFFRV2QmGwtSfHoi5CSxe4qKleSTlzejKq/OZDoVpb/MmVYKSHSe61DkcjtDUOJzyueYex+lSk51twDcJZ2fGd4uXuGg+Ozyvj6W9zUtBoUnKnJpLtOY7jtOlZ8kSF4NDPk4e70+6YZXoOFIEg0XLhQteHA6hmzClaXmJi+aZx0QTnvozswpPUbEwQkqWSi8exz8ZxO7QMzAwkVBNjH6uudBqhXRvq1js3JucnC9a4uJsY2yHYVaWgcIiC6OjQoTDwkXxj0l2nGBwWiBbRsEPFv3FINFzzcXq1VlEkDEVCNHQMJQwPqK80kRb61jCCqeycmEcRyTM0aP9KQnPoiUumhqHpMdEj2/FbcpoI3rS48w8xuXUk5tnwuvx09AQm3FWs9hJU8NQUsVJrZZz2eVCuXNry0jSTLtFS1w0JSBgTpee4mILfn8Ip0vPr39zE0qljKNHjyKXy1myZElMlMwXv/hFnnvuOV5//XXy8/OTXttbhWQEa/v27ajVaqxWK1dffTX33Xdf2iP2LkOaYKUBCDU5N954I1deeSW//OUvUavVdHd3s23bNrZu3cobb7zB4sWLqaurY/PmzRQXF0tkC4R0ZFHZGh8fx2az4XK5cLlcqNXquOcbHvbx3M5Wnt3ezJt/6WR6OoIxQ0j2np6OoNUqOHggdeyBGJApPibRRuHFxCesWp3FqZMDVFTaUankCQ32q1Znc+Rwb9IgxMwsA4sWOenunuDM6YGk24vRkQ8iRKO5ySQYzQsKzDMqUYroiJmsrFAoLG15hYKxqpxYgDxfeOPIiOADSpaInijBXYRouLbZtBw71pdSkVu+IpMTx/vjVvILiyx4RwM01g9Suyz+MXOxbIVQpyIUO9sxmTSSmimidnkmp06kPs6atdlMhyMEp8JJ87JqlwleoETkQUxzl8tlHDrYnXKktbTWzZmoLxCiMqZUCvERHk+AyqoMWlvGE5IrEaLCY3foKCgw4R2digs3FR+TTClSKuVCqbU/xLlz3qT+tmSKk9WqpazcOvPaRjhzJnX9TUmpno4LfunaE20V1ixycvZsarJ3+RV5PP7EzahUMo4dOwbA0qVLY8jVv//7v7Nlyxb27NlDcXFx0mO9lUhEsP74xz+i1+spKiqitbWVr33taxiNRvbt2zevxzWNdw7SBCsNAHp7e/nTn/7E3XffHUOcQPjg6u/vZ/v27WzdupVXX32VqqoqiWxF11CAEOsgKlujo6NYLBZJ2UpUSzE05GP3c63seKaFvW92smx5JidPDFBZLXybqz8TnxmVKj4BBF9SVbWd9rZRyTCdCGvX5rB3znGUSjnV1XZ0ehWtLSOUldtSPhfEVruIJve5waYXU/+ydl0OAwOTCbO2pOdKce1i7Y7NruPAvq6Um2WJoiyEkZZ5Zgw5dFFxF2JnoEIhmL2NRhXnznnoj1IqKqv0nG2aTGoeB7h8fS6BwDRTU2EakhT9rlqdxaGDvQkDVkXCo1LJePMvXSlJ9YqVWRw90is9JlFe1oqVmRxNEm4pYvnKTI4f7cfl1iclPMtXZHL8WH9SoqtQyFi2wsb4eICR4Qg93YlVudplQkjtXNIoesZCoTByOZw8kZgQihBN5uJjikssuDMNMRlnFzPOW7TYyfn2UYpLLKjUcloSKLELaxycPTvMVBJVMzPLwMKFDoaG/Jw62Z909Lz2shx+98QmNBo5x48fJxwOs3Tp0hhbwr333svjjz/Onj17KCsrS3rebzUSEay5OHfuHCUlJbz00ktcc801b93JpfE3RZpgpfH/C5FIhJGREZ555hm2bNnCSy+9RElJCZs3b6auro7q6uqYKAe/3y8pW16vF7PZLClbOp0u7vieER+7n29j544WXn/tAlNT4ajMKBlt57zkF5hSJnlHxyfAjEm+yMyoJyCNNy4mL0qplFG7PJPxsSlMJg0tLUMMDsQqW9HZVImQkaGmqtqOxazh9Tc6Ykzu0ZDJBJVsbieekLVlZGBgputvdfKYChEiAZstCVbEjSHnI6gAV6zPIzA1jW8ycQJ+quPIZJCTqyE7x4pep+K1V+cLRo09TvRIS+xnvJhzFit9cnKEyI5EI625JdJzoVTKufLqfMbHp2g756UvyRgyGdkT09xDoTBqjZzDB3tTkrQFC0w0NIxKpKy4xILbbYgZoc5H0kAgYGfPjlBWZkWtliccPc9V0ubCnWmgpsbJ4OAkp08NJCU8ibYFo0fPXZ1jmC2ahP6uaJSUGujq9OP3Twv9kFU2iEBT45C0CLN6TTa/f3IzOp2CEydOEAwGqa2tjSFX3/nOd3j44Yd57bXXqKqqSvp8bwcuhmABOJ1O7rvvPj75yU++NSeWxt8caYKVxv8JXq+XHTt2sGXLFv785z+Tm5srka3orR6AQCBAf38//f39jIyMkJGRIcU/JEqGHxsN8OIL7ex8toVXXzmPTq8kM9OISiVHq1XQ1CiMVqJhsWjIyjYmDa10OHRUVtlRq+Xsea0j6Y3PaFRRVBwbHQFQWmrB6TLQ2THK8LCPklIbJ08kz53S6hRUVto5fqwfnU5J9QIHMrmMxvpBqdxYo5GzYGHq+he1Ws7yFVmEI5EYohgNsWomEWmU8q4sapRKOW/M0/W3YmVsSXKM76pe6D9MRAjnYs2abPbt65YiGBIVcS+sMXH6VPL8KrVazhXr8xgbC8akksc9V5KeQ2GL1ILfP43BoGTvm/Oc85zjiCOt3u5xabFhPpImPubUyQHKK2yoVLOjwGgsWGiioX40qbInjp57eibiglWjkYiAiYTHbNHS2eHF5TIkVMCisaTWLXkhpUJskIzqcHH1NwtrHPh8IVwuAx6PoIbOfa0qKi20t48S8Mefjxh9UV5h47v/fRU6vZKTJ08SCASora2N8Xh+//vf58c//jGvvfYaCxcuTHpObxcuhmB1dnaSn5/P9u3b2bRp01t3cmn8TZEmWGn81TA2NsZzzz3Hli1beP7553E4HGzatIlbbrmF5cuXx5CtqakpBgYG6O/vZ2hoCIPBIJGtRB1hExNB/vJ6B9u2nuWlF9oYHw9K5cQGo4qW5hF0OgUyUsceZGUbUauE4mezRUNFhY2pqdiQTLdbj8Gg5tw5T9LjOBw6CgrNqNUKwUuSwLtktWlxOvUJK1lEdUmvVxKYmubo4eTkam44KMxGT4hjSLVaQWmplZMnk+d7aXUzdTTH+ikts+Jy6enqGo+Jm7gYspdhUrNiRRZjY1NJ07UVChm1yxKTPXemgaIiC2NjAQwGJQcPJA9hBYGoiEROJoOKSsHk3tExKpVhX4y6tXZtDidO9lNZKSw2NEaRBhHzjXFzczOoXuig88JoQpIrHScB2VMoBJIrxm7Y7QrOnB5NSdJWrhJ8huFwBLNZI2SczdmmnDvuTITa5Zl4Rnxkuo0MDvkSvieX1ro4czrxtqFYf+Nw6jg7T/1Nohodm11LaZmV4NQ0DfVDFBdbaG/3plwGqV5g4fdPbsTlMnP69Gl8Ph/Lli2LIVc/+clPeOCBB3j55ZdZunRp0mO91RgfH6elpQUQfGI/+MEPuOqqq7DZbNhsNu69915uu+02MjMzaW1t5Utf+hJjY2OcOnUKjUbzNp99Gn8tpAlWGn8TTE5Osnv3brZu3crOnTsxmUzcfPPN1NXVsXr16hgjZzAYZHBwkL6+PoaGhtDpdLhcLtxuN0ajMc4T5veH2PPqBXbuaOGF3W14vQGqqu2o1Qr0eiXnkox1SsusjIz44yIKQOjqq5pJcr9wfpSOC8lvIAUFJqaC4RhzsBChYGJo5uaVkyucd2cKspeZZUCjVtDZOSbdeNvmrOM7nToyMjQpyV5+gYnCQjNjY1NJzdpms6DsNTbEK3v5BSZycox4PAHkcllcAXI09HplDJFTKuVUVdvR6ZWcbRrAMxJCo1VQVeVIGQqrUslYtNhNa+vITObUNGfODMZ4deRy4SZ7+lTyay8uMVNSaqXtnCdlvlk0SRMxO0JVXrzXLorIiaQhEJimIYqgXwzZW7jIxMjwFHl5Vvr7fQmXC1KpZBqt0DzgdOg4cXwgZbRIInXL6dRRXGqdiXAYoKbGxal5gj2jlSuhk1NPb29sRVWqjkIRNYudqFUKFAo5zc3DCTsaq6ot/Oe3qwhMjSKTyZDL5VRXV+N0OqXPg4cffph7772XF198kRUrViR9vrcDr732GldddVXcf//whz/MQw89RF1dHceOHcPj8ZCdnc3111/Pf/7nf+J2u9+Gs03jb4U0wUrjbw6/38+LL77I1q1beeaZZ9BoNNx8883ccsstrFu3LsZLEQqFGBwcpL+/n4GBATQajaRsmUymOLIVDE7z5hud7H7+HM8+0yx5TsorbNjtOjo6vHR2jLNkqYuzTanjE2oWOWlr8xIKhqmotOLzTdDZGWByYpawVFfb6epKneG0fEUmGq2CkZEADWcGE94gi2fyveZ20EUHm05MCNleqXLCsnNm0tBniJxeL8QYKBRyybvkduvR6VQpw1ztDh0Wi4bx8SBFRWZGx+LN2vOVJMtkULPIgdNl5GzjUFIlUadXUpZAbRMN+jK5jHMtw2TnGDh9KvmCglIpY/ESt1RDlDVTwyISzXBYIGnLV2Ql9ciJWL0mG48ngNWmpeOCV1LGopFsBAmznjG7Xcu+vV2SfygRFi4ycfpk7EhU7HcUTfIrV80/fhU9YEDMKDD63JevzOTYPEb9VauyCIUjyBIkqotIFekgZn3JZXD8xEDCPDERFZU2OjvHpMck6mhcWOPgqW23YrFoOHnyJF6vF6vVytDQEF/+8pcpKCjAarWyfft2XnjhBdasWZPydUojjbcLaYKVxluKqakpXn31VbZs2cL27duJRCJs3LiRuro61q9fHxPpMD09zdDQEH19fQwODqJUKiVly2w2x5Gt6ekw+/Z2sWtHK8/tbKWvTyAmV12TT8A/TVfXGOfbE3t9Vq4SIg3mfoOPNopHgBPH+ucNSowmcjabsNLu809Tf1owDS9Y6ODC+dGUAZmVVTZ6eyewWXW4swxxZdYgJON7PIGEipx47qvW5EibZYmUApghaTJZ3NjHatVSXmHD7w8xODiJUqlImV5vs2uxWrXS6n1RsZnMTCP9/bPr+CaTmuxso1QNlAgGg5KSUiHRWq9X0Xx2hKGh2GtUq2WUlluoP524Pshq1VJeacNoVPGX1zuSZnPJ5bBseVbcKLNwZrmgf2CS1pYRVq5OXcQNs8qVSiWnaiYgdG635MKaDE6fSq5qAly+Po+AP0QoGKa+YTDhYsSq1dkcPJBY3RLPXamW8eYbqbcp524mit4ng0ElqakXk5dVvcBOe5sXtUYhbTRGjzFBCMXt6RlP+b6/6poCfvbz67FatdTX1+P1elm2bBkajYZwOMxLL73E9773Pfbt24dKpeL6669n06ZN3HzzzW95WnsaacyHNMFK421DKBTijTfe4KmnnmL79u34fD42btzIpk2buOaaa2IiHcLhMENDQ5JJXqFQSNuIVqs1YbTE4UO9vPlGB797/Iyk8OSLZuuoDa2LiU9YvUbIwaqoFGIIElX2zM3lmouMDDWr12QzMuLn9KmBhKM8EIzGjfVDcdtXYnXN0JAPtUpOW7s3pVpQWWWjp2cCrycQ4/+JHkOWlFrwegJJjeMgdP0plDLsdh2RCDTUD8YpgVnZRhSK5CPR7BwjZWVWQtMR9v6lM6nvKJFKNjcY1TPiJzNLR2tLcqKi1c74zY73J9xIhNkxZaoibrkc1q7LJRSKMDYmpLEn+vsmGkGCoOqVlduw2TQEpiY4diS5mR/ix4tSsbNKztmzw3hGAhdlsF+5KovDh3qxO3QUF1uETdD62E3QuWXKibD+qjxCwTDd3fEEX4RIrua+J8RRsUajwOebor1tNGVsSHmFja3P3ordrqOhoYGRkRGWLVsW8znwpz/9ic985jM8++yzZGdn88wzz/DMM89w7Ngx+vv7ycjISP6ipJHGW4w0wUrj7wLT09Ps3buXp59+mu3bt+PxeLjhhhuoq6vjuuuui9kyDIfDjIyMSFlbgKRsWa3WGDO9iOPH+tj5bAu7drZIN4q8/AwqK+1cuDBKUwpFJZGnJrqyp73dS2GReV6SJkYIRCLR4zBoODPIxIRwc1q1WrgxplIdlq3IpK9ngtw8E6NjgbhRHgg5RqnS2cvKreTnZdDROZ505AeC6jAwMBnT46fRKigvtzA15aO7awq7Q8/ERChu3BmN7BxhcaG7a3zWoO+PLTd2OnUYDOqUo0whAsGKUqVIWn2jNygoKDDTUB9/XbMKjRpksD+FV2ruCBKQQl3FMu1AYJoVq7I4uD/1CHLBwgzOnB4jP99ETm4GwzNdgdGYj+grFDKuurqAiYkp2ttHkwaErlydxeEE8RHRW4FymWzeENq524LZOUYKCkyMjs6OYKurZ2qGUjQglJZZGBz0kZlpxGrV0t01FpfvVlpqZeuzt+J06WlsbGRoaIjly5fHkKtt27Zx5513snXrVjZs2BDz+x6PB4vFkvQc0kjj7UCaYKXxd4dwOMzBgwd5+umn2bZtG319fVx//fXU1dVxww03xGwZirlcorI1PT0tKVt2uz0h2ao/M8jOHS00NQyxa2crAHa7GpdbRSSioalxmEhEGLHVLHKlVDgUChnLV2QxPOzD4dBLPpK5WL02m/1J/DsajYKqagdOl45DB3riVvljjpNAvYgeQzacGWDJ0sx5b561tW7OzMQtFBaayco2CkGTUYRlYY2TtnOelDfPqmqhHFijVdLWOkJ/f7wSVlRsZmx0KqFKJqb3K1Vy+nonkqokkJiAiTd970x0hTFDhdmspLMjuSKn1yspKrZQf2ZQ6tub+3dTq+VUL3CmNOobjCpWrcpmbGxKCidNhOoFRurPxJMhsQLG5wtiNKrZOx9Bn0PASkotuNyGGKKZanQoYtmKTOpPD1JWbkWnU3GuNXaMCak9VyAQ3dplmYyPT3Hq5EBcEHD0OQ4O+vDOeU/n5ZvIzRV6NYNT02x99jZcbj1nz56lv7+f5cuXx+Tk7dy5k49+9KM8+eSTbNy4MdXLlEYafzdIE6w0/q4RDoc5duwYTz/9NFu3bqWjo4NrrrmGuro6brrpphjjeyQSwev1SspWKBSSyqgdDkfCCoqmxkF+/as3eWPPAG3nBAXG7tAJYxmlnNf3JM/K0umVlFfYOHEsNgersEggLH29E3Rc8LJ4iVsKPU0EuRxWrBI8PuJWnn4mRT6alCRKnZ+Ly6/Ixe+flvKqkvl3ko0ys7KNFBSaUKvkHNjfk9JvVrNIKBwWR0PRBn2RsCQqf56LoiLBmD42PiUEyqrkNM/JjMrONoJMUMCSoaTUQk5OBh5vIEYZi4bJpCIrOyOhYllYZCY7y8jQ8CRqtTIuAy0aKpWMmkUuKc5CqZRTWWnDGDWCFVROIw31yc8ZBIX09KkBSV1qrJ9VNKXHzKNuZWUZqFnspLtznPoEiqaIRBuF4hjTbtfR1TWGxaKZ13NVWWWno0MoyBaDgOeGmxYVC40AyQrEAQoKTWzfcRuZWUaam5vp7e1l+fLlMYr17t27+dCHPsTjjz/OrbfemvRYaaTx94Y0wUrjHYNIJMLp06clsnX27FmuvvpqNm/ezMaNG2O8WJFIhNHRUSlFPhAI4HA4cLvdOBwOlEolgUCA48ePo1AoWLx4Md1dk+zc0cJrr56n48IY7W3epFlZNrsWu10XF5oZDaNRxYKFTuRyGUODvoSVPalyp+RyGeUVNqw2DSqlgtf3zJeGHrvlFl3/IqWhX4TfbNWabA4d6MFmE2IIJiaCNMzx7yxbnsmpk/0pK1muWJ/HdDhCT/d4whgCELbKenviCZiYcWY0qhgfn6KvbzLlCDIzy4BSIZeM+qIyFkEYwU5OhjCZlRj0cnp6kvuAjEYVefkmRkb8FBUK25QNcwiLoG45OH4secBsWbkFkzlMT3eQ7q7kapoYxBoNjUZBZbUdrUZBS4uH8ouIj4hWNqOT5BuiTPLLVwjKZqrx86LFTsbGpsjMNDAyEqCpMT7rq7LKRkfHWEL/n+iXc810DTY0JB8/5+Wb2LbjNnJyjLS2ttLV1cWKFStiyNXLL7/M+9//fh555BFuv/32lK9BGmn8vSFNsNJ4RyISidDU1CSRrdOnT3PFFVewefNmbr755pi8nEgkwvj4uES2fD4fFouFsbExrFYrNTU1caPE7q4xntvZys6dLRzcLwQ9GjPUVFbZUCoU9PXOpnongtOpw2TWxHiE3JkGiosteL1+GuqHyMhQk5uXQf2ZxKnzEJsELyaKd3fGelhSJbiLUKvlXHZFHhPjUwkrVEQky3AyZijJzlaj1enQ6zXSa5IMtcszOR1FwLJnVvm9noCU6n0xI8iyciuDAz6cLj12e/woDwQTfiAQiskPi4ZGo2DZ8kw0GiXHjvUmVVRMZjVutyGONItdf8HgNG3nPOTlm1OqW0qljKISHc1Nwvnk5WWQm2diZMRHYxThSGaMj8badTkMD/uxWjV0dowlHj+nOM5sGbeG48cG4rYxo5FoLCj0alrxz2R9FRVb6OoaZzzFJmBBgYmx8SmGh/wUFJrJyTYyNMdzlpNjZOuO2ygoMNPa2kpnZyfLly/HYDBIj3njjTd473vfy//8z//woQ99KOXrlEYaf49IE6w03vGIRCK0trayZcsWtm7dytGjR1m7di2bN29m06ZNZGVlxWwZdnR0cPbsWZRKJcFgEJvNJpVRR8dEiBjon+T551rZ+WwLg4OT9HRP4PeHZmpvYk3qINxgAlPTKfOryiusZGYZGRnyU1+fuALFYtGQmWlIGGkg+qaGhibR6VVxY8pozCVgYm2OyRS7UZgq50nEmrXZnDjeT2W1HYVcHrOVJ2LV6mwOHUxOwBwOHUtr3QwO+lIW/FYvmDFQz1FKoj1jEWBkxJ+UMIJA7iIR6Okel7YpTSYhvFUMpDWZFOgNCnpTqFsGg5LSMhtKpRy5XJYwxV6lklFQqKOlOTHZczr1lJRaMGao2PPqhYRjTBGJyG50fERL88hF/c3EpHdA+rvPNclfXP2NE51OCURoahxOuBGYn29icjKY0G/ndOopLrGgUMr4wY+uobDIQltbG+fPn2f58uUx3sp9+/Zxyy238MMf/pCPf/zjKa8vjTT+XpEmWGm8qxCJRLhw4QJbtmxh27Zt7N+/nxUrVrB582Y2b97MK6+8wgMPPMDOnTspKSlhcnJSUrZERUs0ySeqrBge9vHnmTLqN/bMlFHPmNTVajmBQIj29tE4U280CotM+CZnFZdEY0h3pgGtRhG3bRUNi0WDO9PA+NgU+QXmhJtpOr2S8nIbJ44nJmBC9YyN/HwTDfXJw0EhMQGLzgk7e3aEykr7vOOslauyOHJY2JSUOg5DsZlPi5e4aGocTlkUXFFpIxgM43br8XoDNNTHj7MKCkxM+pJvOJaWWcnKNuCbDKX0yZlMajKzjDEbl2Lelc6gorV5hLGxANm5Gtpak6tE0blbYrlxJByhoX4oJubgYtLg11+ZRyAwzfi4MMJNRNJXrMzkyOG+hGS3pNSCy2UAWYSjR/pSeq7mZlgplcI2ptGooq1NaE7Iy8vA759OmSrvdhvYtuM2iksstLe3097ezrJly2LiFQ4dOsSmTZv4zne+w6c+9amUr0Eaafw9I02w0njXIhKJ0N3dzdatW9m6dSuvv/46kUiEW2+9lW9+85sUFRXFKFs+n0/aRvR6vZjNZilFPnpdXMToaIAX/9zGrh2tvPrKeaqq7DSdHaak2ILeoOLs2eE4ZaV6gZ3OjrGkeUAGo4oVK7OYDoY5fKQ36XZWMgLmcumllPju7jFcLkPKCArtTOWK6CcSw0H7+sY51yqMQC82DX3tuhw8nkCcMhaN1WsFM3+iTx3RM2a2ajl+pC8mGmIuFtY4aDvnjRkviuMscZuyoNDM8JCf4SQBqxBrnhdHeXOJqsEgx2JV09WZ/Dh6vYLCIi1qtYahwWBCoqpQyFhS6+ZIAiKn0Qh/B61WiVot543Xk5dxQzwBS9RTuGKlQGRTjXJF5cpu01JYZGF0NBDnOSsrt9LbM5EyIHTlyky0OhWdnWNJ/XYOp45tz95GWbmN8+fPc+7cOZYtW4bJZJIec+zYMTZu3Mg3v/lNPvvZz6Z8DdJI4+8daYKVxrse4XCYe+65h8cff5yPfexjHD9+nNdee43q6mrq6urYvHkz5eXlMWQrEAhIypbH48FkMklZW9Hr4yImJoK89sp5djzbwot/bmNiIohcLqOqWgj3PNc6Qm6eiTNnBudNxBYJmFarpHqBYFJvqB+UiokLi0xMToToT2H6drv12B06jEY1gcA09Qm26kwmNTm5GTTUJ/aAOV0aysqEm/4rL19I+lwymVBKfGB/rLol9tV1dY5x4cLoRaky4nhRMLnb0elUtLSMxKTVL1nqoqFhKOXruGixMM4KTUckk/tcpPJuOV16SkosTE2FGBnx03YuuZKoNyhxOJRcOD9LwOaO8pRKGYsWu1KWaIPgpzp4oEeqjzl/3hu3OTnf66jVKrl8fS6j3gBNTcNJPWfJohhEz1koGMYfCKX8QgDCCHY6FJZeR9FvNzo6W7dks2vZ8sxtVFXZ6ejooKWlhdraWsxms3SckydP8p73vIevfOUrfPGLX0z5OqWRxjsBaYKVxrseH/nIR9i7dy/PP/88JSUlRCIRhoeHeeaZZ9iyZQsvvfQSZWVlbN68mbq6OqqqqmJM71NTU5KyNTw8jNFolJStaFOuCLGMWiRbXm9gtuvOquV8u5fuBCGRtcvcSQmYOIqzWAXjfKoS6YICE/7AdEzhtRgyGQ5HqK8fJMOonrdE2mhUUVBo5szpQYlwjM3ZqlMqZSxemliVicaVVwt1RdG1OXORzE8U3Vcnk8k4eKA7ZcbXgoUO2ttm1S0xUVytVnC2aQiPJ0BRsZnR0amkNUMgkFS1WsHo6JSkDtWfiS3T1uvlWG1KujqTE5C8vAzKK4Tqo7nqUDRWrY4nqQDFxRbcmQYGBiZwuQzz5mWJKe7hcASFQkZFpeC7On9+1nd1MfU3pWUWRr1T5ORmxCTJRyMr20gkEknqN7RYNSxZ4uYb915G9QIHnZ2dNDc3s3Tp0phg0Pr6em688Ub+7d/+jX//939PeX1ppPFOQZpgpfGux2uvvcbChQtxOBxxPxOzs3bs2MGWLVt44YUXyMvLY9OmTdxyyy0sWrQohmwFg0EGBgbo6+tjeHgYvV4vKVsGgyFhGfXev3Tx7DPNPP9cqzQyLC214nIL6s7586OsXiMoN6lW6JcsddHYMEwwOE1VtQODIT4rq7zCRn//RMrsoeISCy6XnunpSEKTOoDVJsRQtDTHx1BYrVrKKqxMBULIZHKOHU2uyiQaLybaKLyo+IgZdauo2IzLbaCne4z2tlhlafESF42NydUthULGustziUTgbONQ0s3DaGN8NKJVxc7OUWSyIN1dycmVRiOnssoheeCiNxIb6ofw+6eRyQQj+nwj2DVrc2hv91JQGKsORSNZiruIklILRcUWOuZpLygtszDQ74uJzxDJmtksmOQjkQgyoCfFMofZrOGpbbewaLGLrq4umpqaWLp0KVarVXrM2bNnueGGG7jzzjv51re+lfI1SCONdxLSBCuNNKIwNjbGrl272LJlC7t378bpdEpka9myZTFkKxQKMTAwQH9/P4ODg2i1WolsZWRkJC2j3vlsC8/vOhdVRl2A3x+ir3ciqX9l5eosjiSo0Imu7Jmenub0qcTjMBFzC6JFZUyphMbGQSbGBYO9RqPgQgqDvThe7OgYo7LSRnimozDaM3YxXX/iRmFv7wT1ZxIbtSG5uiUkghsZGvJjzFBx6sRAXGF3NKqq7XR0jEkxA2XlVhzO2OiL+WIfAKxWDTp9hIwMPVarnnMJUuzVGhnFxWYaGzwJjyHUJdmx2XUc2NedcgyXaCxotQoJ/lPBsJTgP1+Ke/S2YFa2kcJCE16vQHRFspYsfT0a7kwDmZkG9HpVUlXSZFLzp623sGSpm56eHhoaGliyZAk2m016TGtrKzfccAMf+tCHuP/+++P+zaSRxjsZaYKVRhpJMDExwe7du9m6dSu7du3CZDKxadMm6urqWLVqVUwy/PT0NIODg/T39zMwMIBKpZLGiGazOe7GEQ5HOHyoh71/6eTx356hayYgUyp0jgomvRjv0vIVmZw80U9+gRmnS09Xh+B7ikb1QgcXzo8mzTBSKGSsXpuNUimn/vRgXH2KCLtDh9msiSOD0epOe5uHrCwjJ1PkRc1Vt0SjdigUpqF+dhR3MerWylVZdFwYJb/QzMT4FPVn4tWdhTVC8nyyfsb8AhMlJUL59dEUqpzdrkWhmKa/f1b5i05D7+wYZWhokuwcPS3NyUe5crmQF3b4YG/MRuK5ltjqmotJ8F+7LodAYBq5DJqaEkcopIpiEMmaUimjpdkzr79PpVJIoa4gJMkXFJqlEbJer+LJp+tYtiKL3t5e6uvrWbx4MXa7Xfqd8+fPc/311/Pe976XH/zgB2lylca7DmmC9Q7C9PQ03/zmN/nd735Hb28v2dnZfOQjH+HrX/96TKjmf/zHf/DLX/4Sj8fDunXreOihhygrK5OOMzw8zN13382OHTuQy+Xcdttt/PjHP5ZyaF577TWuuuoqRkZGJJ9Ed3c3GzZswGq1smPHjhhz6qUAn8/Hiy++yNatW3n22WfRarXcfPPN3HLLLaxduxalUik9dnp6muHhYfr6+hgYGEChUEjKlsViSXgjSVRGnZVlYOEiJ50dY0mN6JC4nxBiK3ssFs28Bvvychv9A8J4UYhvsMd5xrKyjSgUspQeMJNJTV6+CYVChk6voqV5JM7rNJ+6JZZh2+069r7ZKRn8L/b6xVGcGH1RvcAxrzFeLCX2jASEUNgiM96x2FGc06UlEplmcCD5+RiNKqoXOFAq5JLJfS7kCli82MWxo/HxGdGVQ1qtgldfSb5gAELy/sGo658ttBZGyAMDvovKuSopsTA07GMqME1llUCU52Z9OZ06NFplyr9/do6RX/z6RpavyKKvr48zZ86waNGimBF9Z2cnGzZs4KabbuKnP/3pJU+uIpHIJf8avBuRJljvIHz729/mBz/4AY899hgLFizg8OHDfPSjH+W//uu/+Nd//VcAHnjgAe6//34ee+wxioqK+H//7/9x6tQp6uvrpaiBG2+8kZ6eHh5++GGCwSAf/ehHWbFiBX/4wx+AeILV2trKddddR3V1NU899VTCLbpLCVNTU7zyyits2bKF7du3I5PJ2LhxI3V1dVxxxRUxYaXhcJjh4WHJJC+TyaScLavVmrKMuvnsMDueaQFmAyrH56gzF6NurVyVTW/vODk5GQwN+WKynETMl6peUmohLz+D4SE/J08kV6USqVtifYrFouHcOS9er5/ycjsnTyQPR43eTFSr5VQtcKBRK2huHmEkKnbhYq5/9ZpsQqFw0p4/EDK1errHEyo/s56zKbq6vAz0Jx/BJsrLyswyxNTuyGRQWmakqXH+jsJ9e7soKDSRk53BwOBkXMp8MnItQiYT8rKmgmG6OsaS5qoVl1gYGfbHRWNE510NDk4SCITpuJB8dKzTK/n9Hzexdl0u/f39nDp1ikWLFuF0OqXH9PT0sGHDBq666ioefvjhhP8GLiVEk6vOzk5yc3Pf5jNK46+FNMF6B2Hjxo243W5+/etfS//ttttuQ6fT8bvf/Y5IJEJ2djb33HMPX/jCFwDwer243W5+85vf8P73v5+Ghgaqq6s5dOgQy5cvB4Qy1ZtuuonOzk6ys7NjCNaFCxfYsGEDV199NY899liMUpOG4MN6/fXXeeqpp9i+fTuBQICNGzeyefNmrr766piw0nA4jMfjkcqoI5EITqcTt9uNzWZLeKNpPjvMrh2t7NrZItWzWK1ayiutZGSo508DTzBec2cayM7WMjQ0TseFAEtr3Zw5PZiy2DnaPJ9fYCI3J4P+gQlamj3SYzKzDCiV8nnVreoFDmQymRTfMBcKhYyltYkLsqWtOLMatVrB66+l7mcUU8xFb5cQCmtHrVFwdibCIFlifDSysvX4fFNMTUFVlQOZTPCcRZM1i0WDw6lPqFiJcLn0LFzkYHg4QP2ZAaYCif1iq9dmsz+B58ydaZDKsY0ZKg7u75nXcxW9LVhQYCInJ4PBKKJdVGTG4wmkzB0TIz/UajlOp57uBAsGOp2Sx/9wM5ddkcfAwAAnT56kpqYGl8slPaavr48bb7yRNWvW8Otf//qSJ1fRuO222ygpKeG73/0u4XA4/dq8C5AmWO8gfPvb3+YXv/gFL7zwAuXl5Zw4cYLrr7+eH/zgB9xxxx2cO3eOkpISjh07xpIlS6TfW79+PUuWLOHHP/4xjzzyCPfccw8jI7M3gVAohFar5amnnuKWW26RCNauXbu44447uOOOO/jJT36SlrDnwfT0NG+++SZPP/0027dvZ3R0lBtuuIG6ujquvfbamBLbSCSCx+ORlK1QKITT6cTlcmG322P8XSLOt3vZtbOV53e1EA7DkcO9ZGSoqayyEwqFqT8zQCDqhn0x6s4V63OZmgozMRFMajJPpW5lZRspKDQxHQxz4cJoamN4gs1EsfZGNEqr1UL5darNxOhrK6+wJe0onE/dUShkUhp6S/NI0nPPzdMzNhrA640loGIps0atoK9vAoVCnnRJAZCUOLHWyGBQUVFlRy6HxvohaQxaVW2goT75Zp54bU2Nw5SWWeM8ayLmGwu6XHoW1DiYmAhy9HBv0soim12LKUNDe3ts96boF/R4/LS1eXjs8ZtZf1U+g4ODnDx5kgULFuB2u6XHDw4OctNNN7F48WJ++9vfJnyPX8q4/fbbefXVVzl27Bg5OTlv9+mk8VdAmmC9gxAOh/na177Gd7/7XRQKBdPT0/zXf/0XX/3qVwHYu3cv69ato7u7m6ysLOn3/uEf/gGZTMaTTz7Jt7/9bR577DGamppiju1yubj33nv51Kc+JREstVrN7bffzm9/+9u39DrfDQiHwxw4cEAiW/39/Vx//fXU1dWxYcOGmN61SCTC6OiopGxNTU3hcDhwu904HI6EN6JEZdQGg4rKasFErFEr5s1LiksDT1DZU7tsfnWrtMzK0KAPpVI+M8aMr25xu/VotcqU1T/FxRYKi810d44l7F+E5KGmMOM5yxLImsuln7ejb8lSFw31Q9K1CWRNS1fnuKSs5RcYGBn2MzaW/PrtDh1mkwadXhnXcShCq1VQXmFLOl5Vq+VUVtvJdBs4crgvZSlzonJnvV4545uS0dQ4TGGReV7PlWBKDzA85J+tLIpKggeBFFssGskXmAgajYJHH9/I1dcUMDQ0xIkTJ6iqqor5DBoeHmbjxo2UlZXxxBNPvKVK+Ouvv873vvc9jhw5Qk9PD9u2baOurk76+cX4Vt8K7N69mw996EN8+tOf5hvf+AZyuTz9pfYdjvS85x2EP/3pT/z+97/nD3/4AwsWLOD48eP827/9G9nZ2Xz4wx/+qz/f5s2b2bZtG2+88QaXX375X/3472bI5XLWrFnDmjVr+N73vsfRo0fZsmUL9913H5/85Ce59tpr2bx5MzfddBMmkwmz2YzZbKasrIzx8XH6+vpobW3l9OnTOBwOXC4XDocDlUoFQHZOBv/8ySX88yeXMNA/yXO7Wtm1o4XDh3qoqLRz5EgvS2vdKJXxRmVIrG55PQFpo89gVLH+qnxGRvzIFck/5KsX2LlwYTb2QOyhs1iFjcBAYBqvx0/AP52SXJlMatQaBa+8dB6YTVIfH5+ioX6I6WkhNLN2WWZCcgXQ3ualvc3LmrU5nD/vZfXabDwjQgTBXNQuz+TUif6YSIdo31RBoYnsbC09PaMpyZXLpUOrU8UFtpaWWXG59HR2jtHfP0FpaXJyBTA1FUanU/HCn9ulBgCLRcP586MxSe6VVfo4cgUwORmSUuKXLHURCUNtrVsyuc9FNLkCGB2dksrANVoFS5a60OmUjI8HpdF0IqhUcn75yI1cfU0Bw8PDnDhxgsrKyhhy5fV62bx5M4WFhfzhD394y20GExMTLF68mI997GPceuutcT//7ne/y4MPPhjjW92wYUOMb/Wvibnjv+npaRQKBTfccAMrV67kj3/8I1//+tdRKBRp8/s7HGkF6x2EvLw8vvKVr3DXXXdJ/+2+++7jd7/7HY2NjX/1EeHw8DBf+tKXeOKJJ3juuee44oor3srLfVciEolw+vRpnnrqKbZu3UpzczPXXHMNmzdv5j3veQ9WqzXmA1UkW/39/UxMTGC32yWTvEi2ojEy4mP3c7Fl1CqVnIIiPSol9PUGKSu3JyUpItasFVSSSCQ6fkFGY8OQFEwqBp+mKmQuKjIzPR3B5dYnzMoCQSWx2bRJE94tVg0VlXYyjCpe39PB1FTynKtEkQbigsDEeJD6+kFql7k5eqQvZahrcUkGPT0T+CbDMXlR0YXS7kwDKqU8Jq5gLvR6JTWLXCjkshjf01ysWp3Fgf2Jg0aLSywz2WRyXnslteds7lgwOj5C9LwVFJiYmAjGBNTOhcWiwe7Q0d7mlcJF29q8MYntSqWcX/z6Rm7aWILH4+Ho0aNUVFTEjLfGxsbYtGkTDoeDrVu3JixQfyshk8liFKyL8a3+rRBtaBdJ15EjR1i/fj333HMP995779/sudN4a5BWsN5BmJycjDM+KhQKwjMrZUVFRWRmZvLyyy9LBGt0dJQDBw5IrfRr1qzB4/Fw5MgRli1bBsArr7xCOBxm1apVMceWyWT84he/QC6Xc9NNN7Fr1y7Wr1//N77KdzdkMhk1NTXU1NRw77330tjYyNNPP83Pf/5z7r77btavX8/mzZu5+eabcTgcGI1GjEYjJSUlTExM0N/fT0dHBw0NDVitVilrS9xctFp1fOCOaj5wRzWjowGe39XME384xrEjXiIRWLTYxcREkNVrsmlOEJ8A8eqW3z+rjqjVchYvceFw6Dhxoj8luSqvsNHXN4HXE5BGblqtckZZE8iaTqdEp1MlJVcAfl8I32SQA/u6MRhVLFrsIhKJ0FA/FBOqumZNdsK8qIGBSUlZu+zyXKamplm0yEl9/WCMZ01EaVkGnR0T+P3Cz3q6x6VEd6FQ2sZ0OExf7wQdF5KTK4NBSUGhOYbMut16iopnK4ciEcGIn4xcAZxr9eB263ntlQ5ycozkF5jxePxSCr6IkhI9DQ1DBKMIaCQSq8wtW5GJQa+ip2c8KcEymdQxZv36M4NRr40Vp0vPQP8EX/7aGm7aWILX6+XYsWOUl5fHkKuJiQluu+02TCYTW7ZsedvJVSK0tbXR29vLtddeK/03s9nMqlWr2Ldv39+MYH3mM5+RRoJ33XUXJpMJtVpNfn4+l19+OTt27ODOO+8kJycnrWK9g5FWsN5B+MhHPsJLL73Eww8/zIIFCzh27Bh33nknH/vYx3jggQcAIabhO9/5TozcffLkybiYhr6+Pn7+859LMQ3Lly9PGtMQiUS46667eOyxx9i1axdXXnnl2/USvGsRiURobW3l6aefZuvWrRw7dox169axefNmNm3aRGZmZsyHrM/nk8qoR0dHsVgskrIl/p39fj9Hjx7FYDBQXFTB3je72bqliZdeaJfKqKPjE/r7Jli1Ot7fMxdiIbFMhlTZc641dhQ1tw8wEQoKTbjdBmQyOHs2Nn5BhEBSLDE3eREarYLqagdKpRy1RsGbb3TOe97Rpncxa0sWZTIvL8+g/fw4U4HkH4t5eRlMBcNMTgSprIr3LYGQhZWbZ0o4nhRhs2mpXZbJ4NAkDWcSkz1InmLvcOgoKbXi84eQyyLUnxlKqe7l55uYnJxVrsSNxOgxbEaGiswsY1wcRDQUChk/+/kG6m4tx+v1cvToUUpKSsjPz5ce4/P5eO973wvArl27YhY83k7MVbAuxrf618DcseCvfvUrdu7cySuvvEJmZiY33HADn/vc5ygqKuLQoUOsW7eOH/7whzHTijTeeUgTrHcQxsbG+H//7/+xbds2+vv7yc7O5gMf+ADf+MY3JAVDNGz+4he/wOPxcNlll/E///M/lJeXS8cZHh7mM5/5TEzQ6IMPPpgyaDQSiXD33Xfz6KOPsnPnTq666qq3/PovFUQiEc6fP8+WLVvYtm0bBw4cYOXKlWzevJnNmzeTm5sbQ7b8fr+0jejxeDCZTFitVnp6erDb7XHl1X5/iNdeOc/OHa1SGbVSKWPtZbkEp8IJN/JEJNtMnA0m1RAORzh+vD9lqGdBgYlJX4iBmcRwhUJGZZWdjAw1bec89PVNYjZrcGcako7VxN+rXZbJsaN9VFXb0etVtLTEK3PzpcGr1XJql9nwjvro6QrhSVITU1BgYnIyJCliIrRaofZGqZTT3TWGwahOed5yOSxbniX5npJtFCYjV9FYtNhJV9c4xcUWpsMRGs4M4PPFvvaZmVqCQRgaShzFYLZoWLBQKMTev7crbiNx9rxl/Pin1/K+26sYHR3lyJEjFBcXU1BQID3G7/dz++234/P52L17d8xCx9uNt4tgidixYwfXX389Go2G4eFhenp6+OY3v8nBgwfp6+vj4x//OFdffTU7d+7k4MGDbNu2LeazO413FtIEK400/o4RiUTo6upi69atbN26lTfffJOlS5dSV1cnGYejyVYgEODChQucP3+eSCSCyWSSlC2DwRB3/GBwmjde7+Dg/m5++9hpyfRcXGzBnRVbqHxRlT0rMzlxrJ+CwuSVPeLWYbLcJZkMli51Y7FqaWoaoqszcSCnSiWjZpFLGl+KkMtlVFbZMJs1tLePUlhknrdqp6rKRHPzGKFQJCHZAygsMjE2Fkw4VhVhNmvIzDKgVivQG1S0No/EjeKiK3ISQdgodAgbhUd6Uz5foigGUdlTqRQ0NQ1hMCjx+YKMDCfvOjQYlOTlmWhsHEanE8ji3CR3mQx+8ONr+cAd1YyNjXHkyBEKCwspLCyUjjM1NcUHPvABRkZGeOGFFzCZTEmf8+3AXIJ1Mb7V/wuilatnnnmGf/zHf+QDH/gADz74YIyBvqGhgSeffJLHH3+csbExvF4ver2ehx56iPe///2SET6NdxbSBCuNNN4hiEQi9PX1sX37drZs2cJrr73GwoUL2bx5M3V1dZSVlfH888/z29/+lvvvv5+cnBypjHpoaAiDwSBV9iRSFaanw+x7s4udO2LLqAsKTVRU2jjX6okJFp0LcXQYDsd+pEjxCX0TaLSKmK3DRHC79ajVCklFKym14HIZ6OmZJXtarYKKSjsnjidPgweho6+/bxKXW09XZ+Ik8+oFJpoaR5lOINqIJvHsHKFyKFVlkcWqwW7XxfjJoiuHLlwQTOJLat0cSRCiGg2RzM4li6IXDObPuQLIz8/A4dSj1ihoa/UkzPrS6RQUFJppbIhX3JRKOVXVQu3Oe/+hkn/8p4WMj49z+PBh8vPzKS4ulh4bDAb5p3/6Jzo7O3n55Zcl9fvvCclM7l/4whe45557AMG36nK5/s8m92hydfjwYY4ePcp3vvMdPB4PH/zgB/ne974X14px6tQpTpw4wQ9/+EOOHTvGggUL2L9/f8IvR2n8/SNNsNJI4x2ISCTC0NAQzzzzDFu2bOHll1/G7XbT09PDpz/9ab797W/HKFvBYJDBwUH6+voYGhpCp9PFkK1kZdS7drTQ1ublhd1tgNAzV1BgZnjYR1NUVtXFFDIvWuxkbGyKzExj0sqenFwj4ekIPT2Jgzbz8k0U5GegUMrZM0+K+5o12eyb4yebm0K/YKGJhvrRuGLoaJSWWRkYmMTrCcT0O0aHitrsWixmbVxcQzSUShmr1+YwHQrT2zuRNFsqlVJYWmbF6dQDEY4e7Us5hs3JNRIKhmNIVVm58PtdXeOcb/ei08lxuTWcb0+ukgF853tX8pGPLWJiYoLDhw+Tm5tLSUmJ9PNQKMTHPvYxmpubefXVV7HZbCmP91ZifHyclhahcmrp0qX84Ac/4KqrrsJms5Gfn39RvtX/C+677z5+9KMfsXjxYnQ6HadPn+bChQv88z//M9///vfJyMggGAzGbAVPTk7y4IMP8oMf/ID77ruPO++8M212fwciTbDSSOMdjkgkwsMPP8xnP/tZFi5cSH19PQUFBWzatIlbbrmFmpqaGA9WKBRiaGiIvr4+BgcHUavV0jaiyWRK+CF+7Ggfu3bEllG7XHqKS6wYDEpeefl8ysqW2mVuTp8aiDFhuzMNFBdb8Hr9NNQPkV9gZnIiGOdvikZGhoqcXME8npVloLDIgtfjpyFqoy5VGGnMOS23EPCHCIUEv1Si86+otNHdNc5YAsUtJ8dIXoEZ38QUXm+A9vbkOV9KpYxFi2PHmWISejRZvZgxrFh/43IZyM3NiCO7kJhczUVpmZWCAhMdHWMp/WL3ffsK/vmTS5icnOTw4cNkZWVRWloqvU+mp6f55Cc/yYkTJ3jttddiegf/HiB6Sufiwx/+ML/5zW8uyrf6v8Wf//xnNm7cyJe//GU+/elPk52djdfr5ROf+AR79uzhpptu4kc/+hFms1kaA4rKVygUYvXq1ZjNZl5++eX/87mk8dYjTbDSSOMdjh/+8If8x3/8B9u3b+fqq69mdHSUXbt2sWXLFnbv3o3b7ZbIVm1tbVzI4dDQEP39/QwMDKBUKiVly2w2JyRb9WcG2fFsC7t2NGOz6di/r1uKL/D5gpw5HZviPrcPMBGWLHWh16sYG5tKWtljsWpwOBJ3/YkbdZOTU+j1qpSxBwALa0ycOT0qkarZ35+tDKqutnP+QuqOQqdTh06vwjcZorjEEvP7IlQqGQtrXCnrf5wuPUtr3fR0jye9fojvFhQhkF0hRd/r8TEVjMSlyUdDq1VQWmbl9KnBuN+PTuH/4IfcvPcf8rBarfT395OZmUl5ebn0vgiHw9x1113s37+fPXv2kJmZmfQ5LyWIJOn73/8+X//61zl06BALFy6UlKrJyUk++clP8vvf/56PfOQj/Pd//zc2m036PVGt+sY3vsEjjzzCvn37yMvLe7svK43/n0gTrDTSeAcjEonw+c9/ng9+8IOsWLEi7ucTExM8//zzbN26lV27dmGxWNi0aRObN29m1apVMcbZcDgcQ7ZkMplEtiwWS8Ly2bNNw0Jlz45m6WYdXbmj0ymlwNJkqKyy09U5JqlEZrOGikobU8Ew9acF1cvh0GHMUNPelryyRamUsXiJm5bmEen3G+b0MwLULDJx6mRytcls0bBiRSZe7xQnT/QljU+Y6xWL/v2KChvB4DTNZ4cpLbNz/Ng83YpRI1azRUN5uY1QcDomq+tiPFfZ2UZ0eiV2u45gMHFHoVaroKzcljShXTz/jZtK+dg/19Dd3U1zczORSAS1Wk13dzdGo5HrrruOL33pS7z66qvs2bPnku/Pix7h9ff343K5+PGPf8znPvc5Dh06JOUOikpVMBiktraWlpYW6urqePDBB3E6ndJxhoaGuO222+jp6WHv3r3Y7fa38/LS+F8gTbDSSOMSgc/n48UXX2TLli3s2LEDrVbLpk2bqKurY+3atTEVJuFwmJGRESn+IRKJSNuINpstIdk63+5l544Wdu1o4djRPlavyeHUqQEqq2yEpyPU1w/inxMfsLDGybnWkZjA0GgYjCpqazORyeHQwZ64FHgRyUqiDQYVVdV2IkDDmUFKSvUpyRVAzSInzWdH8PtDMf2OjfWDTEwIz5+ZZUAhl9HVlXjDUTynRYtdhCMglwkp9uLvRyOVf03M6srIUHPyRD/DCbLCRGRlGyES61+b7SiU09gwyNTUNBWV9pS1PQBf/upqPveFlfj9fg4fPozdbqe8vJyRkRF++tOf8stf/pLJyUnUajU/+tGP+OAHPxhn2L5U8eCDD3Lfffdx5MgRWlpauOaaa/jKV77Cv//7v0tm9UAggEaj4dOf/jQ7duxApVJx/fXX88ADD2A2m4lEIhw/fpw777yTb33rW9x4441v81Wl8b9BmmClkcYliKmpKV5++WW2bNnCM888g0wmY+PGjdxyyy1cccUVMYbbSCSCx+ORKnump6dxOp243W5sNlvC9fGumTLqXTtapM3C6PX/hvpBSsusMWXLiRBtek9W2SMUKds5eSL1RmHNYhMBfxiT2cjZxuG4fkaAxUtcNDYkPieNRjETrKqkv38yZRinRiOnotIRc04ajYLKKjsarYKzTcN4RgIXvRzQ2DgMkQhV1Q60WkVcMGtmlgEZJF0OACGKYdmKLKYC00lT/AE+/8WVfOkrqwkEAhw+fBir1UpVVZWkzkQiEb761a/yhz/8gbq6Ol555RX6+/u54YYb+OIXvxjXCPFuR7RyVV9fz6233sqVV17JPffcQ1lZGXfeeSePP/44P/vZz/jABz4gEdHJyUk++tGPsmjRIjo6OnjiiSf41a9+xfve9z5AyBMTa3vSeGciTbDS+LtAV1cXX/7yl3n++eeZnJyktLSURx99lOXLlwMX13g/PDzM3XffHROg+uMf/zhlgGp3dzcbNmzAarWyY8cOzGbzW37tbzeCwSCvv/46Tz31FM888wxTU1O85z3voa6ujquuuiqm4iQSieD1eqUU+WAwiNPplMqoE5Gt/r4Jnn/uHDufbWHf3i5CoTArV2URDIaFrKbGIbze+GDPuWGk0VCp5FQtcKDXKwkGpzlyKPUIbkFNBmdOzY7yVCo5lVVC/IBINpbWujlzeiBlGnpOrpFQKMLQoI+qKjt6Y3zWlVaroLzcxskUJckKhYyrrs5nfDwYk7U1F8nGgkJ8gx2TSY3H48PrDcZEOMyFSiVjwUInx4/1S79fXmHDao0tlP7Xf1vO1/7fWgKBAEeOHMFkMrFgwYIYcnXvvffyu9/9jj179lBWVkYkEuHkyZNs376da6+9lnXr1iU9j3czTp48ydDQEPfccw+PPfYYNTU1ADQ1NXHPPffw0ksv8ZWvfIW6ujry8/N56qmnuPfee/npT39KXV0dFRUVVFZWsmPHjrf5StL4ayFNsNJ42zEyMsLSpUu56qqr+NSnPoXT6aS5uZmSkhJpFfyBBx7g/vvvj1mlPnXqVFwFUE9PDw8//LBUAbRixYqkFUCtra1cd911VFdX89RTT6VHHAj+kL/85S88/fTTbN++nbGxMW688Ubq6uq49tprY16jSCTC2NiYpGz5/X4cDgdutxuHwxEzchQxPOzj5RfbefaZFva8ep6pqTBKpZzqajv6KLJTUmphZNifciSWkaEiJyeD5uYRqqrtGI1qWltiK3sAqhcaqT+dnHzI5TKuuiYf32SI1paRpGQnLy+DQGCa/jmETyYTfGQWi4bu7nEyMjScPpV6BBe9LRhdyBydon8xniu3W49SJUenU+Fy6ensHOPCnKwvpVIIZE1lsi8ptfC+2yv5t8+vZGpqisOHD5ORkcHChQtjFh3uv/9+fvGLX7Bnzx4qKytTXuOlhJaWFsrLy7HZbFLdTTQaGhr4wQ9+wK9//WvUajUajYbx8XE2bdrEtm3bALj22mvp6uri1KlTCf/tpPHOQ5pgpfG24ytf+Qpvvvkmb7zxRsKfX0zjfUNDA9XV1Rw6dEhSvXbv3s1NN91EZ2cn2dnZMQTrwoULbNiwgauvvprHHnss/YGWAOFwmP3790tka2BggA0bNlBXV8f1118fE1YaiUQYHx+XlC2fz4fNZsPtduN0OmNGjiJGRwO8+Oc2dj7bwmuvXsDnCyGXy7jsilwiYTjbNJSU7FgsmphCYhHRZKe93YvVKqP+THJyBUL6/LEjfdLmXHlFPNlJVpETDZ1eSXGxBb8/hMtloLtbyJqai7VrcxKWUosoKjZTUmKl48IoTSniE9xuPUqlPM4HVlBgIicng4HBSdrbPPNuMALc+S9L+NZ/XUEwGOTw4cMYDAYWLlwY47X77//+bx588EEp4DaNWQwNDfHII4/w05/+lL6+Pnbs2ME111wT51XcvXs3b775JlNTUxQVFfEv//IvgDBafP/7309paSlPPvkkSqUynXn1LkCaYKXxtqO6upoNGzbQ2dkpbSN9+tOf5hOf+ARwcXUWjzzyCPfccw8jI7M33FAohFar5amnnuKWW26RCNauXbu44447uOOOO/jJT36S/iC7CITDYY4cOcKWLVvYunUrnZ2dXHfddWzevJmbbroprhJlYmJCUrbGx8ex2WySSV7szYx9fJCXX2rn9Vcv8MKf2+jvn0QmE8iOza7jfLtXGmPZHTrMJk3KUE+5HCoqjYyPh8nNtdDVOR5X2QOwclUWhw/1xqXPiygqNlNYaGJwyM+pFMZwvV5JYVF8KfVssOkkLc0j85IriFWucnMzyMs3MTLii0lad7v1qFQKOjsTd0aCMIZctTqbSDiCd2yKxvrBhIGqH/34Iu7/7pUEg0GOHDmCTqeLy077yU9+wgMPPMArr7wS828wjVn09/fz1FNP8fWvf50VK1bwq1/9KqYAOxkaGxv55S9/yU9+8hO2bNnCzTff/BacbRpvBdIEK423HeKI7/Of/zzve9/7OHToEJ/97Gf5+c9/zoc//OGLKmT99re/zWOPPUZTU1PMsV0uF/feey+f+tSnJIKlVqu5/fbb+e1vf/uWXue7BeFwmFOnTvH000+zdetWWltbueaaa9i0aRMbN27EYrHEkNbJyUlpG3F0dBSr1SqRrWh/lwi/P8SeVy+w49kWqYwahGDM7GwDExNBjhxOrsgoFFBSauBsU6zhu7DQTFaOkf7eCVpbPaxancXBAz0pIyRKSiwMD/sZGfGTl5dBbp4pLoXeYFBSUGim/kzyGh2A9VfmEZiaxusJ0BgVjBqNVGNB50xWVXBqmsFBX9woMPY1kLFkqZsjh2creWw2LWXlNvz+EPVnBggGI3zowwv57vevIhQKcfToUdRqNYsXL44hVw8//DD33nsvL730kqQOX8oQs6omJiaYnJxEJpPhcDgAQcl68skn+fKXv8xll13GL3/5S3Jzc4FZM3y0Kf7JJ5/kW9/6Ft3d3TzwwAPceeedb9t1pfHXR3ouksbbjnA4zPLly/n2t78NCHUWp0+flgjWXxubN29m27ZtvPHGG1x++eV/9eO/2yGXy1m8eDGLFy/mW9/6Fg0NDTz99NM89NBD3H333axfv566ujo2btyIw+FAr9dLpcB+v5/+/n56e3tpamrCbDZLWVsi0dZqlWy4sZgNNxZLZdS7drRy5HAvrS0eurrGJbI0t7JGqZRRVKyLI1cA7e1e2mdGdldenU/AP01ZuS1pinlpmYWBAR9ej0DwOjrGpJGhO9NAUZGZiYkgoVB4XnK1Zm1OTLWP3aGjtNSKzycEk4ZCkXk9VwP9kxCJoNEqGRubYsXKLIKh+KwvuRyW1ro5PKfvcHjYL6XbGzPUfOozi/jqv69henqaY8eOoVKp4sjVI488wn/8x3/wwgsvpMkVs+TqzTff5D//8z85efIkRqORsrIyfvazn1FYWMiHPvQhVCoVX/jCF/joRz/Kr3/9a/Lz8yVSJf5/KBTC6XSybt06brzxRm655Za389LS+BsgrWCl8bajoKCA6667jl/96lfSf3vooYe477776Orq+quPCIeHh/nSl77EE088wXPPPccVV1zxVl7uuxaRSISWlhZJ2Tp+/Djr1q2jrq6OTZs24Xa7Y5StQCAgKVsjIyNkZGRIlT16vT7u+MnKqIXKmQwGByeIRIK0NCf3SQGsWZvNvr2zNTput16o7BkN0FAvKEtl5Vb6+yYTbjeKyMhQkZ2TwcDApJRiL5Kl2OdLXX9jNmtYsSoLz4if06cG4oJBRTidOrQ6FR1zRp0Gg4rKKjsyGTQ1DlFRZefwwdRl0u+7vZIf//Q6IpEwR48eRS6Xs2TJkpgt0Mcff5wvfOELPPfcc+kvIlE4cOAAV199NUuXLmXdunX4fD6effZZxsbG2L17NytWrGBsbIynnnqKL37xiyxZsoSHH36Y0tLShMfz+/1/lc7DNP7+kCZYabzt+OAHP0hHR0eMyf1zn/scBw4cYO/evRfVeC+a3A8fPiwlJr/wwgvccMMNCU3uZrOZf/mXf+H3v/89u3btYv369W/Ltb9bEYlEaG9vZ8uWLWzbto0DBw6wevVqNm/ezObNm8nJyYkhW1NTUwwMDNDX18fw8DBGo1FStsRwxmiEwxEOHeyZ6UdsZXBgguwcDWNjYUrL7Ix6AjH9hCLmy52yO3QsWeLC6w1w7Ghf0soak0lNZpYxTv0SU+jFFPWlte4YMpcI0cqVGCwqkwvBqGIwqcOhQ29QpRwLymSwanU2Pl8IjUbB2bNC1tZc3PbeCn7y0PVEImGOHTsGCKpxNLl68sknufvuu3n22We5+uqrU57/pQSv18vNN9+M0Wjku9/9rmT2v/rqqzl69Cjbt29n/fr1yGQyxsfH2bZtGx/+8Ie58847+fnPf/42n30abzXSBCuNtx2HDh1i7dq13HvvvfzDP/wDBw8e5BOf+AS/+MUvuOOOOwAuqvH+xhtvpK+vj5///OdSTMPy5cuTxjREIhHuuusuHnvsMXbt2sWVV175dr0E72pEIhG6urrYunUrW7ZsYe/evdTW1lJXV8fmzZspKCiIIVvBYJCBgQH6+/sZGhpCp9NJypbRaIxbShgbG+OpP71B/ekIf3ljUKrTcTh0lJZZGR+bor5+kNVrctg7T6hnZZWdjg6hfzBRZQ8I5MqdaUgZNAqw7vJc/L4QyASylCitPtVYUAg2taPXqxgZEQqxk0EmEzofDx6Y7WBUKISsrIwMNedaR+jv97GproyHfrEBEJLCw+EwtbW1MeRq27ZtfPKTn2Tr1q1cf/31Ka/xUsPAwACLFy/ma1/7Gp/5zGcA+OhHP8rWrVv5/e9/zzXXXINOp5PqcLxeL/v27eOaa65JuEmbxrsbaYKVxt8Fdu7cyVe/+lWam5spKiri85//vLRFCLNBo6ka74eHh/nMZz4TEzT64IMPpgwajUQi3H333Tz66KPs3LmTq6666i297ksNkUiE3t5etm/fzpYtW9izZw81NTVs3ryZuro6SktLYwhUKBRicHCQvr4+BgcH0Wq1krKVkZHB6Ogox44do6CggKKiIgDOnB5g5w4hRV5UmC5fn0fAHyIQmJYM3nNRvcDO+fZRJibiy50NRhVVM2O4iYngRXmuoseCIllSqxU0NQ7j9QYuKufK7tBhNKjo7ByjqsqOMSNx1tfK1VkcTFFwLZPBRz62iP/89hXI5XD8+HFCoRC1tbUxESU7d+7kox/9KH/60594z3vek/IaL0W0tLRQXV3N9u3buemmm/jEJz7BE088wW9/+1s2btyIWq2mr6+PL3zhC/zkJz+RPmdgtoMwjUsHaYKVRhppvC2IRCIMDQ3xzDPP8PTTT/PKK69QUVEh9SNG17OAcIMaHByUyqjFwtzc3FwqKioSxm00nx3m9dcu8MQf6qUy6owMNZVVdqZDYaEf0T/NgoUOzrV68PkSdx0CWKwa7HYdXZ3jUmVPU4LKnTVrstm3L/lYUKmUc8WVefgmQ5w9O5y0ssbu0GE0quOytGQyqKi0Y7Fq6bjgJTfXJJnXk2HDDUX86jc3oVDIOHHiBFNTU9TW1saoKrt37+ZDH/oQjz/+OLfeemvK412KEMvQL7/8cq6++mqCwSC///3vefTRR9m8eTNarZZwOMx//dd/8eSTT/KnP/2J6urqt/u003gbkSZYaaSRxtsOse/w2WefZcuWLbz44osUFBSwefNmbrnllrjQywsXLtDc3IzRaGRychKFQiFFP1it1oRka24ZdSQi5FetXZfD+HiQkyf6k5ZOW21arBZtXPaWSiWneoEDrVbJ2bPDVFTY2J+CXEHsWFCovLFhNmtoa/PSO9MlaLNrMWVopK3HZFi9Jpv+/kncmQZ6usdob4v3aF1zXSGP/vY9KJUyTp06hc/nY9myZTHk6uWXX+YDH/gAv/71r7n99ttTPuelgGi1KTpWAeDee+/l3nvvBeBnP/sZn/rUp6THvf7663z+85+noqKC3/zmNwkz39K4dJAmWGmkkcbfHUZHR9m5cydbtmxh9+7dZGZmSmPEjo4OPvOZz7B7925qamoIh8OMjIxIwaYymUwqo7ZarXFp2gDdXWPs2tnKoYM9vPjnNsEYrlVQXe1AqZTT1DgkKVM2u1YgQOdSk501a3MYGwskreyB+etvysqtZGYa8PlCcTELc7F6TXYcmcvLN5GXm8HgoI+zZ4e56up8fvO7jahUck6fPs3ExATLli2LufG//vrrvPe97+XnP/85//iP/5jyOS8FiOSqp6eH73//+/T29nLllVdy/fXXS8Ghd911lxRLcscdd7BixQoef/xxHnroIfr7+zlw4AAOhyOOnKVxaSFNsNJII42/a4yPj/P888+zdetWnnnmGfx+P5dffjnf+MY3WLlyZYyvJRwO4/F4pMqeSCQilVHb7faEZEsso961o4W9bwpl1KIyZdCr8I4GOHN6MO73ojGX7IhjPKtVQ3v7KD3d4xflubJYNVitWtrOeeOCUaMx3xgS4ObNZfzkf65Do1Fw+vRpxsbGWL58eQy52rt3L7fccgs//vGP+djHPpbyeJcS+vv7Wb58OV6vF51Ox+DgINdeey1f/epXWb9+PR6Ph29+85s8+OCDyGQyFAoFBoOB0tJStm/fTk5OTtpzlUaaYKWRRhrvDGzfvp077riDT3/60/T19bFz5050Oh2bNm1i8+bNrF27NsawHYlE8Hq9krIVCoWkMmq73Z7w5jc87GP38+fYtaOVhvpBoeuvc0wqk25pHmFwjmcqkZI0F+uvyiMUjNDZMcr5JFELFqsGm1WXsAJIrMwZHvZhs2nnjX5Ye1kOv3tiEzqdkvr6erxeL8uWLYtJzj906BCbNm3igQcekDrxLmWEQiGUSiXhcJjvfve77Ny5k+985zuUl5dz+PBhbr/9dkpKSnjggQfYsGEDAC+++CLnz5+np6eHlStXsmLFCmw2W5pcpQGkCVYaaaTxDoBIrv7whz+wefNmQAgqffnll9myZQvPPPMMCoWCjRs3csstt3D55ZfHeIwikQijo6OSsjU1NYXD4cDlcuFwOBKWfY+NBnhhThl1dJl0W5uXgkIzB/5/eK5gprIn20h//wStLR5AKK+22XUxqfSJsGZtDudaRygqtjA2NkVDgn7B1Wuy+f2Tm9HrlTQ0NDAyMsLy5ctjyNWxY8fYuHEj9957L//6r/+a8jnfzWhvb0etVpOdnQ0IkR/PPfccf/zjH8nPz+dHP/qRNOI7c+YMl112GdnZ2dx///1s2rQp4THFtPc00kgTrDTSSOPvHs3NzZw7d05SDuYiGAyyZ88enn76abZv304wGOQ973kPt9xyC1deeWUMuYhEIoyPj0vKls/nw26343a7cTgcCfOKxDLqXTtaeOmFdiYmgqxanc3wsA+HQ09nx6hUoxON+caCubkZFBWbCUfgzTc6U74GiRLhxX5Bny9EQ/0Ai5e4efLpOvQGFY2NjQwNDbF8+fKYpPCTJ09y00038bWvfY0vfOELKZ/z3Yzjx49TW1vLj370I+666y4UCgWf+tSnePjhhykuLub+++/nfe97H9PT00QiEZRKJY2NjVx22WU4nU4eeOCBpCQrjTQgTbDSSCONdxmmp6d54403JLI1Pj7OTTfdRF1dnRQEGY3x8XFJ2ZqYmMBut+NyuXA6nQm3wPz+EHv/0snWLWdjyqiLiy24s2a3+S7Gc2U2a3A4dbS2eHBnGiguMsdU9ohYuzaHvSnqdgDWXZbLbx5/D8YMNWfPnpV8RNHXW19fz4033sjnPvc5vva1r13My/muRH19PevWrWPNmv+PvfMOb6s83/99NC1LtuRtx0nsOHuR4ZDETsoMCRAoYZdRApQNhUJLGaUFSoEfUPiGAimjLaFtKCMEKJCGEVYhKZDhvUdsx3sPybLW+/vDOcfvkSVPLdvP57p8RTk6kl6tc249434y8NRTT2Hx4sUA+p3ab775Zrzxxhs4/fTTsWPHDiQnJwMYSCFWVFTg5JNPhtVqxd/+9jece+65wXwqRAhDcUyCCDD/7//9PwiCgF/84hfSNqvViltvvRUxMTEwGAy48MIL0djYKLtddXU1Nm/ejPDwcMTHx+Puu++GwzFgK7Bjxw6ZsSEAFBYWYsaMGbj44oths8n9miYrSqUSp5xyCp5//nlUVVXho48+QmJiIu655x6kpqZi69at2L17N8zmfksEg8GAtLQ0ZGRkIDMzEyaTCceOHcPXX3+NQ4cO4dixY+jrGxg5ExamwmkbUvH8nzcir/g6vP7Wj3HFTxejo9OKA9/W4mhlF3500nRERGgwc2aE13UajVrExYdLacLGBjMOHKhDQX4roqLDsGbtNJxwQhwy100bVlydsCwef/t7v7gqLS1FY2Mj0tPTZeKqpKQE55xzDm655Zagi6uHHnoIgiDI/hYsWBCQxy4tLcW6deuwevVq/PGPf5TEFQAYjUa89tpr+MlPfoLPP/8cf/nLX6TvoUqlgt1uR1paGr755hsYjUav8wUJAqAIFkEElB9++AGXXHIJIiMjceqpp2Lbtm0AgJtvvhkfffQRduzYAaPRiNtuuw0KhQLffvstgP6ozPLly5GYmIinnnoK9fX1uOqqq3D99dfjscceA9AvsH7xi1+go6NDeqyzzjoL559/Pl566aUpXxficrlw8OBBaT5ibW0tzjjjDJx33nk466yzEBkZKdu/t7dXimx1dXXBaDRKI3s8DecVh1Hv23cUH7xfhmPHU4bTkg1ISTGivb0XRYX9zvKRkRrEJ+hRVjr0uJ2MdckoyGvxOLJHZPGSWOx67wKYTFqUlZWhvr4eq1atkg3MLi8vx5lnnomrrroKjz32WNCtAx566CHs2rULn332mbRNpVIhNjbWr4979OhRrFmzBkuWLMGzzz4rzRIEgG+++Qb/+c9/8Oijj8JqteKaa67Brl278MADD+DGG29EYmIigP50tFqtlhXFT/XvFuEZElgEESB6enqwcuVKbN++HX/4wx+wfPlybNu2DZ2dnYiLi8Prr7+Oiy66CABQVFSEhQsX4sCBA1i7di3+85//4JxzzkFdXR0SEhIAAC+++CLuueceNDc3Q6PRyATW559/jvPOOw+33HILnnjiiWA+7ZDE5XIhJycHu3btwu7du1FRUYHTTz8d5513HjZv3gyTySQTIVarFU1NTWhqakJHRwciIyOlkT3uKcf+++eGUX9QhtraHgBAfHw45s6PhlIp4JuvawYVqPNkrhs8O1Ec2cMYUFDQgpQUI955/wLExOhQXl6OY8eOYdWqVbIB2VVVVdi4cSMuvvhiPP3000EXV0C/wHrvvfeQlZUVsMfs6OjAggULoNPp8N5772HZsmXSdYcOHcJpp52GjIwMvPXWW4iMjITNZsPPfvYzvP7667j//vtx8803S8XwwGADUoJwh2Q3QQSIW2+9FZs3b8aGDRtk2w8dOgS73S7bvmDBAsycORMHDhwAABw4cABLly6VxBUAbNq0CV1dXcjPz5fd37vvvovNmzfjgQceIHHlBYVCgeXLl+MPf/gD8vPzcejQIaxevRrbt2/HrFmzcP7552PHjh1oaWkBYwxhYWGYOXMmVq1ahZNOOgnTpk1DW1sbvv32W/zvf/9DZWWllHLsv38Ba9ZOw+8fPQkHs6/Bnk8uwa0/T0dsnA5NjWZ8/WUNTFHH04DL4qBSyU/UGZmeB1Obe+w4+EMDDh1swJw5Udj17vmIidGhoqICNTU1SE9Pl4mrY8eO4ayzzsJ5550XMuJKpLS0FNOmTUNaWhquuOIKVFdX+/XxmpubsWDBArS0tKCgoEDanpOTg40bN+L000/HX//6VymSqdFo8Oqrr2Lr1q148skn8eSTT+LYsYFGhFB6LYnQZHBvMkEQPueNN97A4cOH8cMPPwy6rqGhARqNZlD9VEJCAhoaGqR9eHElXi9eJ9LT04OLL74Y999/P+655x4fP4vJiSAIWLx4MRYvXozf/e53KC0txa5du/Dqq6/ijjvuwPr167Flyxace+65SEhIgEajwfTp0zF9+nTY7XY0NzejsbER5eXl0Ov1UmRLr9dL9UUr0xOxMj0Rv31onWwYtThD0GjUYv6CaNjtTuh0Ko/iimf2bBN2vvFjxMaF4+jRo6iurkZ6ero02BwA6uvrcfbZZ2Pjxo2SIWaosGbNGuzYsQPz589HfX09Hn74YfzoRz9CXl4eIiK8162Nh7lz5+Lll1/G7bffjuuuuw4ajQYLFizAhg0bkJGRgW3btkkF7WLaT6VS4eWXX4YgCPjTn/6E2267zS9rIyYnFMEiCD9TU1ODO+64Azt37vRYu+NLdDodzjjjDLzyyisoLCz062NNRgRBwLx583D//ffj+++/R3FxMc4++2y8+eabmDdvHs4880xs374dx44dA2MMarUa06ZNw4oVK3DKKacgNTUVPT09+O6777B//36UlZWhq6sLfCXG4iVxuOe+tfh6/5X4ev+VuOe+tZgxMwLff1ePsDAVsrObserERKxMT0CYbrBZ5ay0/rRgfIIeVVVVqKysxMqVK2XCpLGxEZs3b8aPfvQjvPjiiyFXI3TWWWfh4osvxgknnIBNmzZhz5496OjowFtvveXXx503bx6ef/55nHLKKbj88suxevVqpKenY/v27dIYHMaY9Ho1NTWhoKAAzz77LAoLC6monRgVofWtI4hJyKFDh9DU1ISVK1dCpVJBpVLhq6++wp/+9CeoVCokJCTAZrNJxekijY2NUmFtYmLioK5C8f/iPkB/B917772HlStX4tRTTyWRNQ4EQUBaWhruvvtufPvtt6isrMRFF12EDz74AIsWLcLpp5+OZ599FkePHpV8kpKSkrBs2TKccsopmDNnDiwWCw4ePIhvv/0WJSUl6OzslImtefOjceevVuOzLy/H/w5uxYaNszBvXjQO/tCAw4caIUDAyvQErFqdBINBjZTUSLzz3gVITDKgpqYGFRUVWLlypaxAv7m5Geeccw7S09Pxl7/8JeTElSdMJhPmzZuHsrIyvz/WnDlz8Pzzz+PSSy9Fb28v1q9fL0Wu+Lqq+vp6/O53v8MVV1yB9vZ2zJ8/3+9rIyYZjCAIv9LV1cVyc3Nlf6tWrWJXXnkly83NZR0dHUytVrNdu3ZJtykqKmIA2IEDBxhjjO3Zs4cpFArW2Ngo7fPSSy+xyMhIZrVaGWOMvfrqq8xoNDLGGLNareycc85hCQkJLD8/P3BPdgrgcrlYXV0de+GFF9hpp53GVCoVW7lyJXv44YdZVlYW6+npYWazWfrr6upilZWV7LvvvmMffvgh27t3Lzt8+DA7duzYoH3Fv5KSBrbtmW/ZhlNeY8bw/8ciwh5nyxb9mRUXNzCz2cyKi4vZhx9+yGpra2W3q6mpYSeccAK7+OKLmd1uD/ZLNWK6u7tZVFQUe/bZZwP2mBUVFeyiiy5iarWa/fnPf2Z9fX3SdfX19ezuu+9mgiCwV155JWBrIiYXJLAIIgicfPLJ7I477pD+f9NNN7GZM2eyzz//nB08eJBlZGSwjIwM6XqHw8GWLFnCNm7cyLKystjevXtZXFwcu++++6R9eIHFGGN9fX3sxz/+MYuPj2d5eXmBeFpTDpfLxZqamtjLL7/MNm3axDQaDVu6dCl74IEH2MGDBwcJqO7ublZVVcW+//579tFHH7E9e/awgwcPsurqatbd3e1RbFVWNLEXnjvACgrqjouvEvbBBx8MEle1tbVsxYoV7LzzzmM2my3YL82Q/PKXv2Rffvklq6ysZN9++y3bsGEDi42NZU1NTQFdR01NDbv00kuZUqmUxF1TUxO77777mCAI7K9//au0r8vlCujaiIkPFbkTRAjwf//3f1AoFLjwwgvR19eHTZs2Yfv27dL1SqUSH374IW6++WZkZGRAr9dj69at+P3vf+/1PjUaDXbt2oVLLrkEp556Kj7//HOZ7w8xfgRBQFxcHK6//npcd911aG9vx7///W/s3r0bf/zjH5GamorzzjsP559/PhYvXgyFQoHY2FjExsbC5XKhvb0dTU1NyMvLA2MMcXFxSEhIQHR0tJTai0/Q4+prTwAA1NXVobi4GMuXL5c1RXR3d+P8889HUlIS3nzzTY/jfkKJY8eO4bLLLkNrayvi4uKwfv16/O9//0NcXFxA1zF9+nQ888wzUKlUuPPOO9HR0QG73Y7/9//+H1544QVce+21AMiSgRgb5INFEAThBzo7O/Hhhx9i9+7d2Lt3L5KSknDeeedhy5YtWLFihaw2ijGGjo4OaT6i0+lEXFwc4uPjERMTA6VSiYaGBhQUFGDZsmWIiYmRbms2m7FlyxaEh4fjgw8+8HsjxWSkoaEBDzzwAP72t78BALZt2yYNwSZxRYwVElgEQRB+pqenB3v27MHu3buxZ88eREdH48c//jG2bNmCE088EUrlQLcgYwydnZ2SsanNZoPBYEB3dzeWLFkis+uwWCy46KKLoFAo8OGHH8rc24nR0djYiAceeADp6em46aabAIBc2olxQQKLIAgigFgsFnzyySd455138OGHH0Kv1+Pcc8/Fli1bkJGRAZVqoHKDMYajR4+irKwMWq0Wdrsdhw8fhtFoxLnnnoubbroJVqsV//nPf2QeWMTY6O3tlZz5SVwR44UEFkEQRJCwWq3Yt28f3nnnHfz73/+GUqnEueeei/PPPx/r16/HO++8gxdeeAG7du1CfHw8zGYznn/+efzjH/9AVVUVjEYjHn/8cVx66aWIiooK9tMhCIKDBBZBEEQIYLfb8eWXX2LXrl14//33YbFYYLFYcOONN+LRRx+FRqOR9vvpT3+KsrIyXHTRRfjoo4+Qm5uL0047DQ888ADWr18f5GdCEARAAosgCCLk+OSTT3Deeedh/fr1KCwsRE9PDzZv3oxzzjkHb731FiorK/H5558jOjoaAFBZWYl33nkHJ510ElavXh3k1RMEAZDAIgiCCCm++uornHPOOdi+fTt++tOfwul04sCBA3jnnXfw97//HXa7HeXl5QG3NCAIYnSQwCIIggghnnvuOej1esmDicdut6OmpgZpaWlBWBlBEKOBBBZB+IDt27fj1ltvxerVq/Hdd98FezkEQRBEkKEeVILwATt37kRqaiq+//77gAysDTUef/xxnHjiiYiIiEB8fDy2bNmC4uJi2T5WqxW33norYmJiYDAYcOGFFw4aYF1dXY3NmzcjPDwc8fHxuPvuu+FwOKTrd+zYIXMwB4DCwkLMmDEDF198MWw2m9+eI0EQxGgggUUQ46SyshL79+/HM888g7i4OOzcuTPYSwo4X331FW699Vb873//w6effgq73Y6NGzfCbDZL+9x555344IMP8Pbbb+Orr75CXV0dLrjgAul6p9OJzZs3w2azYf/+/XjttdewY8cO/O53v/P6uD/88AN+9KMf4cwzz8Sbb74pddoRBEEEncCNPSSIyckjjzzCoqKiWF9fH7v55pvZ3LlzB+3T0tLCrrzyShYREcGMRiO76qqrWFZWFgPAXn31Vdm+hYWF7MILL2RRUVFMq9Wy9PR09v777wfo2fiGpqYmBoB99dVXjDHGOjo6mFqtZm+//ba0T2FhIQPADhw4wBhjbM+ePUyhULCGhgZpnz//+c8sMjKS9fX1McbkA6337dvHDAYD+/Wvfx2gZ0UQBDFyKIJFEONk586duOCCC6DRaHDZZZehtLQUP/zwg3S9y+XCueeei3/961/YunUrHn30UdTX12Pr1q2D7is/Px9r165FYWEh7r33Xjz99NPQ6/XYsmUL3n333UA+rXHR2dkJAJKNwKFDh2C327FhwwZpnwULFmDmzJk4cOAAAODAgQNYunSpbBTMpk2b0NXVhfz8fNn9v/vuu9i8eTMeeOABPPHEE/5+OgRBEKNGNfwuBEF449ChQygqKsJzzz0HAFi/fj2mT5+OnTt34sQTTwQAvPfeezhw4AC2bduGO+64AwBw880344wzzhh0f3fccQdmzpyJH374AVqtFgBwyy23YP369bjnnntw/vnnB+iZjR2Xy4Vf/OIXWLduHZYsWQKgf5iuRqMZVD+VkJCAhoYGaR9eXInXi9eJ9PT04OKLL8b999+Pe+65x4/PhCAIYuxQBIsgxsHOnTuRkJCAU089FQAgCAIuvfRSvPHGG3A6nQCAvXv3Qq1W4/rrr5dup1AocOutt8ruq62tDZ9//jkuueQSdHd3o6WlBS0tLWhtbcWmTZtQWlqK2trawD25MXLrrbciLy8Pb7zxhl/uX6fT4YwzzsArr7yCwsJCvzwGQRDEeCGBRRBjxOl04o033sCpp56KyspKlJWVoaysDGvWrEFjYyP27dsHAKiqqkJSUhLCw8Nlt58zZ47s/2VlZWCM4be//S3i4uJkfw8++CAAoKmpKTBPbozcdttt+PDDD/HFF19g+vTp0vbExETYbDZ0dHTI9m9sbERiYqK0j3tXofh/cR8AUCqVeO+997By5UqceuqpJLIIgghJKEVIEGPk888/R319Pd544w2P0ZqdO3di48aNI74/l8sFAPjVr36FTZs2edzHXZSFCowx/PznP8e7776LL7/8ErNmzZJdn56eDrVajX379uHCCy8EABQXF6O6uhoZGRkAgIyMDDz66KNoampCfHw8AODTTz9FZGQkFi1aJLs/rVaL3bt346KLLsKpp56Kzz//fNA+BEEQwYQEFkGMkZ07dyI+Ph4vvPDCoOt2796Nd999Fy+++CJSUlLwxRdfwGKxyKJY7n5Zoju3Wq2WFYNPBG699Va8/vrreP/99xERESHVTBmNRuh0OhiNRvzsZz/DXXfdhejoaERGRuLnP/85MjIysHbtWgDAxo0bsWjRIvz0pz/Fk08+iYaGBjzwwAO49dZbpXo0Hq1Wi3feeQcXX3yxJLIWL14c0OdNEAThlWC3MRLERMRisbCIiAh27bXXerz+22+/ZQDYG2+8wXbt2sUAsG3btknXO51Odtpppw2yaTjllFNYdHQ0q6urG3SfTU1NPn8evgKAxz/+ufX29rJbbrmFRUVFsfDwcHb++eez+vp62f0cPXqUnXXWWUyn07HY2Fj2y1/+ktntdul63qZBxGazsS1btrC4uDiWm5vrz6dJEAQxYmhUDkGMgTfffBM/+clP8N577+G8884bdL3L5UJiYiLWrl2Ld999F5mZmTh06BBuvvlmLFiwAP/+97/R1NSErKws7NixQ7JsKCgowPr166FQKHD99dcjLS0NjY2NOHDgAI4dO4bs7OxAP1WCIAhiDFCKkCDGwM6dOxEWFubRagHo7xLcvHkzdu7ciY6ODnz00Ue444478Nprr0GhUOD888/Hgw8+iHXr1iEsLEy63aJFi3Dw4EE8/PDD2LFjB1pbWxEfH48VK1YM6WhOEARBhBYUwSKIIPHee+/h/PPPxzfffIN169YFezkEQRCEDyGBRRABoLe3FzqdTvq/0+nExo0bcfDgQTQ0NMiuIwiCICY+lCIkiADw85//HL29vcjIyEBfXx92796N/fv347HHHiNxRQSNF154AU899RQaGhqwbNkyPPfcc1i9enWwl0UQkwKKYBFEAHj99dfx9NNPo6ysDFarFXPmzMHNN9+M2267LdhLI6Yob775Jq666iq8+OKLWLNmDbZt24a3334bxcXFkg8ZQRBjhwQWQRDEFGTNmjU48cQT8fzzzwPo73ydMWMGfv7zn+Pee+8N8uoIYuJDo3IIgiCmGDabDYcOHZIZ2ioUCmzYsAEHDhwI4soIYvJAAosgCGKK0dLSAqfTiYSEBNn2hIQEyYWfIIjxQQKLIAiCIAjCx5DAIgiCCBAvvPACUlNTERYWhjVr1uD7778PyjpiY2OhVCrR2Ngo297Y2IjExMSgrIkgJhsksAiCIALAm2++ibvuugsPPvggDh8+jGXLlmHTpk1oamoK+Fo0Gg3S09Oxb98+aZvL5cK+ffuQkZER8PUQxGSEuggJgiACQKh17b355pvYunUrXnrpJaxevRrbtm3DW2+9haKiokG1WQRBjB4yGiUIgvAzYtfefffdJ20LdtfepZdeiubmZvzud79DQ0MDli9fjr1795K4IggfQQKLIAjCzwzVtVdUVBSkVQG33XYbmd0ShJ+gGiyCIAiCIAgfQwKLIAjCz1DXHkFMPUhgEQRB+Bnq2iOIqQfVYBEEQQSAu+66C1u3bsWqVaukrj2z2Yxrrrkm2EsjCMIPkMAiCIIIANS1RxBTC/LBIgiCIAiC8DFUg0UQBEEQBOFjSGARBEEQBEH4GBJYBEEQBEEQPoYEFkEQBEEQhI8hgUUQBEEQBOFjSGARBEEQBEH4GBJYBEEQBEEQPoYEFkEQBEEQhI8hgUUQBEEQBOFjSGARBEEQBEH4GBJYBEEQBEEQPoYEFkEQBEEQhI8hgUUQBEEQBOFjSGARBEEQBEH4GBJYBEEQBEEQPoYEFkEQBEEQhI8hgUUQBEEQBOFjSGARBEEQBEH4GBJYBEEQBEEQPoYEFkEQBEEQhI8hgUUQBEEQBOFjSGARBEEQBEH4GBJYBEEQBEEQPoYEFkEQBEEQhI8hgUUQBEEQBOFjSGARBEEQBEH4GBJYBEEQBEEQPoYEFkEQBEEQhI8hgUUQBEEQBOFjSGARBEEQBEH4GBJYBEEQBEEQPoYEFkEQBEEQhI8hgUUQBEEQBOFjSGARBEEQBEH4GBJYBEEQBEEQPoYEFkEQBEEQhI8hgUUQBEEQBOFjSGARBEEQBEH4GBJYBEEQBEEQPoYEFkEQBEEQhI8hgUUQBEEQBOFjSGARBEEQBEH4GBJYBEEQBEEQPoYEFkEQBEEQhI8hgUUQBEEQBOFjSGARBEEQBEH4GBJYBEEQBEEQPoYEFkEQBEEQhI8hgUUQBEEQBOFjSGARBEEQBEH4GBJYBEEQBEEQPoYEFkEQBEEQhI8hgUUQBEEQBOFjSGARBEEQBEH4GBJYBEEQBEEQPoYEFkEQk5qrr74aqampwV7GqDnllFNwyimn+O3+jx49CkEQsGPHjmH3LS0txcaNG2E0GiEIAt577z2/rWs8+Ps1I4jRQAKLCDg7duyAIAhe//73v/9J+wqCgNtuu21E9/vBBx/g3HPPRUJCAjQaDaKjo3HSSSfh6aefRldXl7+eTkjx2GOPjfnkd/XVV8NgMHi9fjTvBTG52Lp1K3Jzc/Hoo4/iH//4B1atWhW0tRQUFOChhx7C0aNHg7YGghgJqmAvgJi6/P73v8esWbMGbZ8zZ86o7sflcuFnP/sZduzYgaVLl+KWW27BjBkz0N3djQMHDuCBBx7Anj17sG/fPl8tPWR57LHHcNFFF2HLli3BXgoxTj755JNgLwEA0NvbiwMHDuA3v/lNSAjsgoICPPzwwzjllFMGRSZD5TUjCIAEFhFEzjrrLJ/8En7yySexY8cO3HnnnXj66achCIJ03R133IH6+nr8/e9/H/fjhCqMMVitVuh0umAvJShYrVZoNBooFKEdkDebzdDr9SPeX6PR+HE1I6e5uRkAYDKZgruQERAqrxlBAJQiJCY4FosFTzzxBBYvXoynnnpKJq5EkpKScM8998i2ORwOPPLII5g9eza0Wi1SU1Nx//33o6+vT7ZfamoqzjnnHHz55ZdYtWoVdDodli5dii+//BIAsHv3bixduhRhYWFIT0/HkSNHZLcX024VFRXYtGkT9Ho9pk2bht///vdgjMn2dblc2LZtGxYvXoywsDAkJCTgxhtvRHt7u8c1ffzxx9KaXnrpJQiCALPZjNdee01Kt1599dVSrY23v7Fis9nwu9/9Dunp6TAajdDr9fjRj36EL774QrbfKaec4vWxxfqftrY2/OpXv8LSpUthMBgQGRmJs846C9nZ2bL7+vLLLyEIAt544w088MADSE5ORnh4uJQCfu+997BkyRKEhYVhyZIlePfdd0f8fA4ePIhNmzYhNjYWOp0Os2bNwrXXXjvoscX3XsRTLZP4vpeXl+Pss89GREQErrjiCtx2220wGAywWCyDHv+yyy5DYmIinE6n9LqJ9USNjY1QqVR4+OGHB92uuLgYgiDg+eefH9VrORIeeughpKSkAADuvvtuCIIgRY281bY99NBDgz5XYnpZfH+0Wi0WL16MvXv3Drp9bW0tfvazn2HatGnQarWYNWsWbr75ZthsNuzYsQMXX3wxAODUU0+VPkfie+KpBqupqQk/+9nPkJCQgLCwMCxbtgyvvfaabB/xPfzjH/+Il19+WTounHjiifjhhx9G/boRBEARLCKIdHZ2oqWlRbZNEATExMSM+D6++eYbdHR04Fe/+hWUSuWIb3fdddfhtddew0UXXYRf/vKX+O677/D444+jsLBw0Em5rKwMl19+OW688UZceeWV+OMf/4hzzz0XL774Iu6//37ccsstAIDHH38cl1xyCYqLi2XRFKfTiTPPPBNr167Fk08+ib179+LBBx+Ew+HA73//e2m/G2+8ETt27MA111yD22+/HZWVlXj++edx5MgRfPvtt1Cr1dK+xcXFuOyyy3DjjTfi+uuvx/z58/GPf/wD1113HVavXo0bbrgBADB79mzExcXhH//4h+w52e123HnnnR5/8bu/J97o6urCX/7yF1x22WW4/vrr0d3djb/+9a/YtGkTvv/+eyxfvhwA8Jvf/AbXXXed7Lb//Oc/8fHHHyM+Ph4AUFFRgffeew8XX3wxZs2ahcbGRrz00ks4+eSTUVBQgGnTpslu/8gjj0Cj0eBXv/oV+vr6oNFo8Mknn+DCCy/EokWL8Pjjj6O1tRXXXHMNpk+fPuxzaWpqwsaNGxEXF4d7770XJpMJR48exe7du0f0WnjC4XBg06ZNWL9+Pf74xz8iPDwcqampeOGFF/DRRx9JQgHo/6HwwQcf4Oqrr/b4OU5ISMDJJ5+Mt956Cw8++KDsujfffBNKpVK6v9G+lkNxwQUXwGQy4c4778Rll12Gs88+e8g6vaH45ptvsHv3btxyyy2IiIjAn/70J1x44YWorq6WvvN1dXVYvXo1Ojo6cMMNN2DBggWora3Frl27YLFYcNJJJ+H222/Hn/70J9x///1YuHAhAEj/utPb24tTTjkFZWVluO222zBr1iy8/fbbuPrqq9HR0YE77rhDtv/rr7+O7u5u3HjjjRAEAU8++SQuuOACVFRUyL5/BDEiGEEEmFdffZUB8Pin1Wpl+wJgt956q9f7evbZZxkA9t5778m2OxwO1tzcLPtzuVyMMcaysrIYAHbdddfJbvOrX/2KAWCff/65tC0lJYUBYPv375e2ffzxxwwA0+l0rKqqStr+0ksvMQDsiy++kLZt3bqVAWA///nPpW0ul4tt3ryZaTQa1tzczBhj7L///S8DwHbu3Clb0969ewdtF9e0d+/eQa+HXq9nW7du9fp6idxyyy1MqVTKnqu41qH++PfC4XCwvr4+2f22t7ezhIQEdu2113p97G+//Zap1WrZPlarlTmdTtl+lZWVTKvVst///vfSti+++IIBYGlpacxiscj2X758OUtKSmIdHR3Stk8++YQBYCkpKUO+Hu+++y4DwH744Qev+4iPzb+/4joBsFdffVXaJr6W9957r2xfl8vFkpOT2YUXXijb/tZbbzEA7Ouvv5a2nXzyyezkk0+W/i9+vnJzc2W3XbRoETvttNOk/4/0tfS0bk+I+z311FOy7Vu3bvX4uj744IPM/dQCgGk0GlZWViZty87OZgDYc889J2276qqrmEKh8Pg+iN/ft99+2+P7wNjg12zbtm0MAPvnP/8pbbPZbCwjI4MZDAbW1dUle44xMTGsra1N2vf9999nANgHH3zg4ZUhiKGhFCERNF544QV8+umnsr///Oc/o7oPMTXk/qs6NzcXcXFxsr/W1lYAwJ49ewAAd911l+w2v/zlLwEAH330kWz7okWLkJGRIf1/zZo1AIDTTjsNM2fOHLS9oqJi0Dr54mAxXWKz2fDZZ58BAN5++20YjUacccYZaGlpkf7S09NhMBgGpd1mzZqFTZs2DfnaeOPvf/87tm/fjieffBKnnnqq7LqwsLBB74n4545SqZQiYC6XC21tbXA4HFi1ahUOHz7s8bEbGhpw0UUXYfny5di+fbu0XavVSlE/p9OJ1tZWGAwGzJ8/3+N9bd26VVZzVl9fj6ysLGzduhVGo1HafsYZZ2DRokXDviZifdGHH34Iu90+7P4j5eabb5b9XxAEXHzxxdizZw96enqk7W+++SaSk5Oxfv16r/d1wQUXQKVS4c0335S25eXloaCgAJdeeqm0bbSvZaDYsGEDZs+eLf3/hBNOQGRkpPR9cblceO+993Duued6rM0cSzp7z549SExMxGWXXSZtU6vVuP3229HT04OvvvpKtv+ll16KqKgo6f8/+tGPAHj+ThPEcFCKkAgaq1evHneRe0REBADITlZAfyeiKAr+/ve/y1JkVVVVUCgUg7oVExMTYTKZUFVVJdvOiygA0gl8xowZHre710wpFAqkpaXJts2bNw8ApFbz0tJSdHZ2Sikzd5qammT/99R9ORKysrJw00034bLLLhskMIF+0bRhw4YR399rr72Gp59+GkVFRTJh4ml9DocDl1xyCZxOJ3bv3g2tVitd53K58Oyzz2L79u2orKyU6pAAeEwZu9+/+J7NnTt30L4jERYnn3wyLrzwQjz88MP4v//7P5xyyinYsmULLr/8ctk6R4NKpfKYnrz00kuxbds2/Pvf/8bll1+Onp4e7NmzR0pLeSM2Nhann3463nrrLTzyyCMA+oWZSqXCBRdcIO032tcyULh/jwAgKipK+r40Nzejq6sLS5Ys8dljVlVVYe7cuYMaIMSU4nDfdVFsuX+nCWIkUASLmNAsWLAAQP8veR6DwYANGzZgw4YNg8SNyEh/EXur7fK2nbkVr48El8uF+Ph4r9EjvlYLwJg6Btvb23HhhRdi3rx5+Mtf/jLq27vzz3/+E1dffTVmz56Nv/71r9i7dy8+/fRTnHbaaXC5XIP2v/vuu3HgwAG89dZbg4THY489hrvuugsnnXSSVJ/16aefYvHixR7vy9cdk4IgYNeuXThw4ABuu+021NbW4tprr0V6erok3r19XngBw8NHknjWrl2L1NRUvPXWWwD6/dt6e3tlUShv/OQnP0FJSQmysrIAAG+99RZOP/10xMbGSvuM9rUcK6N9PXz5ffEXE2GNxMSBIljEhOZHP/oRjEYj3njjDdx3330jatVPSUmBy+VCaWmprDi2sbERHR0dUteUr3C5XKioqJCiVgBQUlICAFIX1uzZs/HZZ59h3bp14xIP3k56LpcLV1xxBTo6OvDZZ58hPDx8zI8hsmvXLqSlpWH37t2yx3UvwgaAN954A9u2bcO2bdtw8skne7yvU089FX/9619l2zs6OmTiwRvie1ZaWjrouuLi4mFvL7J27VqsXbsWjz76KF5//XVcccUVeOONN3DddddJ0YyOjg7ZbdyjICPhkksuwbPPPouuri68+eabSE1Nxdq1a4e93ZYtW3DjjTdKacKSkhLcd999sn3G+1qOlKioqEGvBTC21wMA4uLiEBkZOejHkjujSRWmpKQgJycHLpdLdmwoKiqSricIf0ERLGJCEx4ejl//+tfIy8vDvffe6/GXpvu2s88+GwCwbds22fZnnnkGALB582afr1NsoRfX8/zzz0OtVuP0008HACl1JqZ+eBwOh8cTmSf0er3HfR9++GF8/PHH+Ne//jXm9KI74q99/vX97rvvcODAAdl+eXl5uO6663DllVcO6tri78v9fXr77bdRW1s7orUkJSVh+fLleO2119DZ2Slt//TTT1FQUDDs7dvb2wc9vtgFKVp3pKSkQKlU4uuvv5btx9eSjZRLL70UfX19eO2117B3715ccsklI7qdyWTCpk2b8NZbb+GNN96ARqMZZCo73tdypMyePRudnZ3IycmRttXX14/KGoNHoVBgy5Yt+OCDD3Dw4MFB14vPSfQSG8l34uyzz0ZDQ4Osbs3hcOC5556DwWDwKPYJwldQBIsIGv/5z3+kX5I8mZmZsrTewYMH8Yc//GHQfqeccgrWr1+Pe++9F4WFhXjqqaekVv3p06ejvb0dhw8fxttvv434+HiEhYUBAJYtW4atW7fi5ZdfRkdHB04++WR8//33eO2117Bly5ZBhd/jJSwsDHv37sXWrVuxZs0a/Oc//8FHH32E+++/H3FxcQD6a4BuvPFGPP7448jKysLGjRuhVqtRWlqKt99+G88++ywuuuiiYR8rPT0dn332GZ555hlMmzYNs2bNQnh4OB555BGcdNJJaGpqwj//+U/Zba688soxPa9zzjkHu3fvxvnnn4/NmzejsrISL774IhYtWiSribvmmmsAQEpZ8Yjv9TnnnIPf//73uOaaa5CZmYnc3Fzs3LnTa3rXE48//jg2b96M9evX49prr0VbWxuee+45LF68eFCNnjuvvfYatm/fjvPPPx+zZ89Gd3c3XnnlFURGRkqC3Gg04uKLL8Zzzz0HQRAwe/ZsfPjhh4Pq40bCypUrMWfOHPzmN79BX1/fiNKDIpdeeimuvPJKbN++HZs2bRpkAOqL13Ik/OQnP8E999yD888/H7fffjssFgv+/Oc/Y968eWMupn/sscfwySef4OSTT8YNN9yAhQsXor6+Hm+//Ta++eYbmEwmLF++HEqlEk888QQ6Ozuh1Wpx2mmneaxfvOGGG/DSSy/h6quvxqFDh5Camopdu3bh22+/xbZt26QaToLwC0HqXiSmMEPZNMCtbXyo/R555BHZ/b777rvs7LPPZnFxcUylUjGTycTWr1/PnnrqKVnrPmOM2e129vDDD7NZs2YxtVrNZsyYwe677z5mtVpl+6WkpLDNmzcPeg7wYB/hqZ1969atTK/Xs/LycrZx40YWHh7OEhIS2IMPPjiolZ4xxl5++WWWnp7OdDodi4iIYEuXLmW//vWvWV1d3bBrYoyxoqIidtJJJzGdTscAsK1bt0r2At7+3NfqDffn7HK52GOPPcZSUlKYVqtlK1asYB9++OGg9n3RVmKo99pqtbJf/vKXLCkpiel0OrZu3Tp24MCBQW334nN5++23Pa7xnXfeYQsXLmRarZYtWrSI7d6926udAM/hw4fZZZddxmbOnMm0Wi2Lj49n55xzDjt48KBsv+bmZnbhhRey8PBwFhUVxW688UaWl5fn0aZhqNeSMcZ+85vfMABszpw5Hq93f+4iXV1d0vvL2w+IjPS1HK9NA2P9NhhLlixhGo2GzZ8/n/3zn//0atPgyW4lJSVlkK1IVVUVu+qqq1hcXBzTarUsLS2N3XrrrTJLkFdeeYWlpaUxpVIps2zw9Jo1Njaya665hsXGxjKNRsOWLl066DkP9RwBsAcffND7C0QQXhAYo+o9gvAXV199NXbt2jVsBIUgCIKYXFANFkEQBEEQhI8hgUUQBEEQBOFjSGARBEEQBEH4GKrBIgiCIAiC8DEUwSIIgiAIgvAxJLAIgiAIgiB8DAksgiAIgiAIH0MCiyAIgiAIwseQwCIIgiAIgvAxJLAIgiAIgiB8DAksgiAIgiAIH0MCiyAIgiAIwseQwCIIgiAIgvAxJLAIgiAIgiB8DAksgiAIgiAIH0MCiyAIgiAIwseQwCIIgiAIgvAxJLAIgiAIgiB8DAksgiAIgiAIH0MCiyAIgiAIwseQwCIIgiAIgvAxJLAIgiAIgiB8DAksgiAIgiAIH0MCiyAIgiAIwseQwCIIgiAIgvAxJLAIgiAIgiB8DAksgiAIgiAIH0MCiyAIgiAIwseQwCIIgiAIgvAxJLAIgiAIgiB8DAksgiAIgiAIH0MCiyAIgiAIwseQwCIIgiAIgvAxJLAIgiAIgiB8DAksgiAIgiAIH0MCiyAIgiAIwseQwCIIgiAIgvAxJLAIgiAIgiB8DAksgiCGxOVygTEW7GUQBEFMKFTBXgBBEKGLy+WC2WyGw+GAWq2GSqWCSqWCUqmEIAjBXh5BEETIQgKLIIhBMMbgdDpht9vhdDrhdDoBADabDU6nE+3t7Zg2bRrUajWUSiUJLoIgCDdIYBEEIYMxhs7OTtTW1iItLU3arlL1Hy5sNhuKiooQFxcHm80GQRCgUCigVCpJcBEEQRyHBBZBEBJi1MpiseDYsWOYM2cO2tra0N3djbi4OBgMBigU/aWbKpVKqs1yuVyw2+0ywcWnE0lwEQQx1SCBRRAEGGNwOBxwOBwAAIVCAZfLhcLCQhw7dgwRERGoqamBIAiIiIgAYww9PT3Q6/UQBAFKpVK6H6BfcNlsNvT19ZHgIghiSiIwag8iiCmNGH1yuVwAAEEQ0NjYiOzsbERERGDhwoVQqVRQq9Xo7u5Gc3MzqqurpbSgyWRCVFQUoqKiEB4eLhNOvOByuVzSdSS4CIKY7JDAIogpCmNMJq7E1F9dXR3y8/MBABs2bIDNZoPdbodWqwUA9PX14dtvv8XJJ5+M7u5utLe3o6OjA52dnVCpVDLBpdPpBgku8Y8XdAqFQqrfUqlUUCgUJLgIgpjQUIqQIKYgjDGpQxDojyg5nU4UFBSgpaUFCxYsQElJiSS6eLEjXhYEASaTCSaTCUB//VZXVxfa29vR2NiIkpISaDQaREVFSaKLF1xKpVImuKxWq3S/ouASI1wkuAiCmGiQwCKIKYYYtXI6nZJw6ezsRHZ2NnQ6HTIzM2G324c1F3W/XqlUSpEroF9wdXZ2or29HXV1dSguLoZWq5UJrrCwsBEJLjGyRYKLIIiJAgksgpgiiN5WDodDlhKsrKxEWVkZ0tLSkJaWBkEQ4HA4JAHlLmRGKmyUSiWio6MRHR0NAHA4HJLgOnbsGAoLC6HT6WSCS6vVehRcLpeLBBdBEBMKElgEMQXwlBK02+3Izc1Fd3c3Vq1aJUWegH4R4y2CJQqZ0ZZvqlQqxMTEICYmBkC/4Oro6EB7ezuqq6tRUFCA8PBwKQpmMpmg0WiGFVwKhWJQ0TwJLoIggg0JLIKY5IjeVmLUShAEtLa2IicnByaTCevWrYNarZbdxl2ceBJT4+2PUalUiI2NRWxsLADAbrdLgquyshJmsxl6vV4muNRqtUfBJbrN87YQfNG8IAgkuAiCCCgksAhiksJ7WzHGoFAowBhDaWkpqqqqsGDBAkyfPt2j8BhJBMvXqNVqxMXFIS4uDkC/Y7wouMrLy2GxWGAwGGSCSxRPYrqTF1wOh0MSVu4pRRJcBEH4GxJYBDEJcblccDgcspSg1WpFdnY2HA4H1q5di4iICK+3HyoNONYU4WjRaDSIj49HfHw8gH57iPb2drS3t6O0tBRWqxURERFS/ZbJZJLEk7vgcjgcsNvtXgWXuD9BEISvIIFFEJMI3tuKMSYJioaGBuTl5SExMRELFy6UnNe9MRIRFWgLPa1Wi8TERCQmJgIArFarJLiKi4vR19eHyMhISXAZjUYSXARBBA0SWAQxSXAvZBcEAS6XC0VFRaivr8eSJUskcTIcI4lgBZuwsDAkJSUhKSkJANDb2ysJrsLCQthsNhiNRpngEmvQPAmupqYmtLe3Y86cOZLQIsFFEMRYIYFFEJMAT95WPT09yMrKglKpRGZmJsLDw0d9v8FMEY4WnU4HnU6HadOmgTEmE1x1dXVwOBwwGo1SDVdERIRMcDmdTpjNZgiCIA2uBgbG+pDgIghiNJDAIogJjDdvq5qaGhQVFSElJQVz5swZtSAIxRThaBAEAeHh4QgPD0dycjIYY7BYLJLgqqmpgcvlkgkuMaUq2j4A8pSrzWaTUop8OlEstCcIguAhgUUQExRP3lYOhwP5+flob2/HihUrJAuE0TKcwBqqyzAUEQQBer0eer0e06dPB2MMZrNZElxVVVVwuVxQKpWorq5GVFQUDAaDVJ8lwgsuu90u3TcJLoIg3CGBRRATEJfLBZvNJvO26ujoQHZ2NvR6PTIzM6XhzGNhOIEw0QWEIAgwGAwwGAyYMWMGGGOorKxEY2Oj5MMlzloUI1x6vX5IwSVGuBQKBZRKpeTDJRbaEwQxtSCBRRATCDElKHYJiqmsiooKlJeXY86cOUhNTR33CZ2PYHm7r4kUwRoOQRAQFhaGsLAwLFu2DC6XC93d3Whvb0drayvKy8uhVCplgis8PJwEF0EQXiGBRRATBE/eVjabDTk5ObBYLDjxxBNhMpl88ljDCayJliIcLQqFAkajEUajEUD/a9/V1YX29nY0NzejrKwMKpVKNkdRp9PJBJf4+ngSXHxKkQQXQUxOSGARRIjjzduqpaUFOTk5iImJwYoVK6BS+f7rHGg392Dj7XkpFAqYTCZJwDqdTklwNTQ0oKSkBBqNZpDgAuBRcNlsNtlYHxJcBDH5IIFFECEMP+4GGIgclZSUoLq6GgsXLkRycrLPT8iiiJuoXYRjYTTPR6lUSqlCoF9wdXZ2SpYQxcXF0Gq1MsEVFhYm3ZZ/PJfLhb6+vkG2ECS4CGJiQwKLIEIUMWrlcrkA9J94LRYLsrOz4XK5kJGRAYPB4Nc1TJYuQn+jVCoRHR2N6OhoAIDD4ZAE17Fjx1BYWAidTieboyg2IYgiSjQ9ZYwNElz84GqxqYEgiNCGBBZBhBievK0EQUB9fT3y8/Mxbdo0zJ8/f9hxN+MlGAOfJwsqlQoxMTGIiYkB0C+4xMHVVVVVyM/PR3h4uExwaTQa6XV1F1xWqxUApJSiWq2WmZ7S+0EQoQcJLIIIIURvq6ysLMyePRt6vR4ulwuFhYVobGzE0qVLkZCQEJC1TLUUIeA/4ahSqRAbGyv5ktntdklwVVZWwmw2Q6/XywSXWq0mwUUQExgSWAQRIvDjblpbW5GSkiKNu9FoNMjMzJQKpwPBUCdpShGOD7Vajbi4OMTFxQEAbDabJLjKy8thsVhgMBhkgos3MB1KcHkaXE2CiyACDwksgggynrytBEFAQ0MDampqkJqaitmzZwd8/p27iOItG0hg+RaNRoP4+HjEx8cDAPr6+iSX+dLSUlitVkREREgF8yaTSVb8zgsul8slCS5x7A8JLoIIPCSwCCKIeBt3Y7fbUVtbi5UrV0p1PIGGF1HiyXsyn5hDSTBqtVokJiYiMTERAGC1WiXBVVxcjL6+PkRGRkqCy2g0ehVcTqcTbW1tqK+vx8KFC0lwEUSAIIFFEEFCjFrxhezt7e3Izs6GIAhYtGhR0MQVMHyReygJkslOWFgYkpKSkJSUBADo7e2VBFdhYSFsNps0uNpkMsFoNEqfKYVCAZfLBYvFAkEQ4HQ64XQ6JR8uMaXIz1EkwUUQ44cEFkEEGHdvKzH1V15ejoqKCsydOxc1NTV+7xIcDlFETUUn91BHp9NBp9Nh2rRpYIzJBNexY8fgdDolwRUVFSWJePEPGIhKihFTUVi513CR4CKIsUECiyACiLu3lSAI6OvrQ05ODqxWK1avXg2j0Yi6urqQEDBTzaZhIj4vQRAQHh6O8PBwJCcngzEGi8UiCa6amho4nU4oFApUVVUhKioKBoNBFuECRi64Al0LSBATFRJYBBEA+HE3fEqwqakJubm5iIuLw8qVK6VxN6EQIZqKNg2TAUEQoNfrodfrMX36dDDGUFVVhfr6enR2dqKqqgqMMdngaoPBIAmq4QQXn04kwUUQ3iGBRRB+xlMhO2MMRUVFOHbsGBYvXoxp06bJbiPWzQQTShFODgRBgFarRVhYGE444QQwxtDd3S3z4RIEQSa49Hq9V8ElDq4GBsb6kOAiiMGQwCIIP8J7W4lRK7PZjOzsbABAZmYm9Hr9oNsJghAyAku87H7dZGMyC0aXyyWz2IiMjERkZCRmzpwJl8uF7u5utLe3o7W1FeXl5VAqlTLBFR4ePqzg4iNc/BxFElzEVIUEFkH4AW/jburq6pCfn4/p06dj/vz5Xk8+oRAhEk/ILpcLnZ2d0jgXkWCvjxg5Q1lsKBQKGI1GGI1GAP3vd1dXF9rb29Hc3IyysjKoVCrZ4GqdTudRcIk/KOx2OwAMEly8WSpBTHZIYBGEj/GUEnQ6nSgoKEBzczOWLVsmGUp6Q0wjBhOxAP/w4cPo7u6G0+lEZGQkoqKipFb/ycZkPfmPxsNMoVDAZDLBZDIB6LcTEQVXQ0MDSkpKoNFoPAouvvOVF1xihEuhUHjsUiSIyQgJLILwIZ68rbq6upCVlYWwsDCsW7cOYWFhw95PKKQInU4nioqKEBcXhwULFkAQBKlup7e3F0VFRWhoaJDSSBEREZQOClHGYxKrVCql9xjo/1x0dnaivb0ddXV1KC4uhlarlfaJioqCVqsdleBSq9VSSpEEFzFZIIFFED6A97YSx90AwNGjR1FaWoq0tDSkpaWNKooQrAgWYwxlZWWwWCyYOXMm5s2bh97eXqjVasns0mKxIC4uDkqlEu3t7aiurgZjTHaSFQulieDjSxd+pVKJ6OhoREdHAwAcDockuGpqalBQUACdTiebozgaweVew0WfIWKiQgKLIMaJy+WCw+GQpQTtdjtyc3PR3d2NVatWSb/+R0qwIlhWqxU5OTno6+uThg17QqFQQKPRICkpSbIC6OnpQVtbm1QoLdbtiH+BHFRNyPHnmCOVSoWYmBhp6oDD4ZAinVVVVcjPz0d4eLhMcGk0GpngEn9MuFwu2Gw2yWWeBBcxkSGBRRBjhP8FLp7ABEFAW1sbsrOzYTKZkJmZKSsMHynBiGC1trYiOzsbsbGxWLlyJQ4ePDhio1FBEBAREYGIiAikpKRIhfHt7e2or69HcXExwsLCZIJrLK+LPwl2zZs/CeQcSZVKhdjYWMTGxgIA7Ha7zBLCbDZDr9fLBJdarQYAElzEpIIEFkGMAfdCdrHrr6ysDEePHsX8+fMxY8aMMR/8AxnB4te9cOFCJCcnS2JxqBPzUIJEoVDI6nY8RTXECJl4khVNVgnfE8xB3Wq1GnFxcYiLiwMA2Gw26bNQXl4Oi8WCiIgIqWCe/yzwgkv86+vrk/lwifVbKpWKBlcTIQUd0QhilHjyturt7UVOTg5sNhvWrl2LiIiIcT1GoCJY/Jge93X7ctize1TDZrNJo1xKS0thtVqlDsWoqChpWHGgmawnZ74uMNhoNBrEx8dLnbR9fX2DPgvugouPVCmVSpngslqtAID6+nrExsYiIiJCZno6Wd9TIvQhgUUQI8Sbt1VjYyPy8vKQkJCA9PR0n0RiAhHBam1tRU5ODqKjo7FixYpB63Y/MfGCarwnLY1Gg4SEBCQkJACAbFhxXV0dHA6HzOgyIiKCTpTjIJgRrOHQarVITExEYmIigP46QPGzUFxcjL6+Pkl8m0wmGI1Gj4KrpqYGBoNBSjeKKUW1Wk2CiwgKJLAIYgR48rZyuVwoLi5GXV0dFi9ejKSkJJ89nuid5Q8YY6ioqEBFRQUWLFiA6dOnj3ocjq+NUHU6HXQ6HaZNmwbGGMxms3SSPXr0KARBkNVvic7ixMgIZYHlTlhYmNStCgwW33a7HUajUSa4xO+jWq2GWq32GOHyNrh6orwuxMSDBBZBDINYaMtHrXp6epCdnQ2FQoHMzEyEh4f79DH9FcESU4K9vb1Ys2YNIiMjh1xDMIY9C4IAg8EAg8GAGTNmyEa5iM7iarVaElvR0dHQarV+WctkIZRShKPFXXzzguvYsWNwOp0wGo1wOBxSAT0vnPiUosvlIsFFBAwSWAThBTElKHYJiieoY8eOobCwEDNnzsTcuXP9cuLyx6gcsbsxKirKY0rQEyPtIvQn/CiX1NRUmdFlbW0tioqKZL5LUVFRUppoNFAXYegjCALCw8MRHh6O5ORkMMZgsVgkwVVSUoLi4mIpwhUVFQWDwTCk4Orr64PVaoVCoRjUpUiCixgPJLAIwgPext3k5+ejtbUVy5cvl7qi/IEvi9z5lOBouhsDmSIcDe5Gl+42AHl5eYiIiJB1KPIGl1MRftjzZEIQBOj1eoSHh6OkpASrV6+Gw+GQBFdVVRUYY7J6PoPBIHXJioiCSxwBJdpCiBEufo7iZHwdCf9AAosgOLx5W3V2diI7Oxs6nQ7r1q3ze0rKVylCm82GnJwcmM1mrF69WhroO9I1BCNFOFrcbQD4rjSxSFqMaERHRw850meynjwnSwTLG+J3RalUIiwsTEovM8bQ3d0tE+CCIMgElzhxwH1wtTidwW63S9d7mqM4mV9XYnyQwCKI4/DjboCBk21lZSXKysowe/ZszJo1KyAHVF9EsNrb25GdnQ2j0YjMzMxRp82Gep7BjGANB9+V5qlmx+VySSfY6OjoKTHSZ6oILHfhLAgCIiMjERkZiZkzZ8rq+cSJA0qlUia4xAaKsQiuiVrnRvgHElgEgYFC9v3792PlypXQ6XTo6+tDbm4uzGYzTjzxRJhMpoCtZzwRLMYYKisrUV5ejnnz5mHmzJljOrkOtYaJcrL2VLPT09MjCa7KykrJFNXlcoWsaBwvU0VgDfcc+Xo+8XZdXV2yBgpxxJMounQ6HQkuYkyQwCKmNHxK0OVyoaenBy6XS/KIioqKGlP0Z7yMNYJls9mQm5uLnp6eUacE3RFPVmNxcg9V+JE+YkRDPMHW19fDarVi//79sg7FUBvpMxamgsDiBdBIUSgUMJlM0o8np9MpfR4aGhpQUlICjUYzasEl3jdfv0WCa+pBAouYsngqZBcEAZWVlaivrx/SI8rfjCWC1dHRgaysLERGRvpEFIZqkbsv4U+wov1GUlIS2tvbUVNTg4KCAtncvKioqAk50mcqCCxfiBelUikb8cR3rNbV1aG4uBharVb2edBqtV4Fl91ul431cZ+jSIJrcjPxjhQE4QM8jbuxWCxgjKG1tRUZGRkwGAxBW99oIliMMRw9ehRlZWWYO3cuUlJSfHIyHU5gTUYEQUBMTAxiYmIA9HcoiunE8vJy9Pb2yjoURVfxUIcE1thw71h1OByS4BIFuLtFiEaj8Si4xGOOGOESBEEmuMQuRWLyQAKLmFJ48rYSBAENDQ3Iy8uDQqHAkiVLgiqugJFHsOx2O3Jzc9HV1eWXOjFeYLmPypkMESx33E9warVaNjePH+NSUFAAh8MxqEMxFE+SJLB8g0qlkglwT0PMw8PDZRYhouDihTgvuGw2myTIRMHFdykSExcSWMSUwdu4m6KiItTX12PJkiUoKSkJ8ir7GUkEq7OzE1lZWTAYDMjMzPR5rdBEsWkIJPwYF3eTy+rqagCQdSiGykifqSCwgvH83IeYu3uymc1mGAwG2eBqtVo9IsGlUCigVCqhVqullOJkfg8nIySwiCmBGLXix910d3cjOzsbKpUK69atg06nQ1lZmd+HLI+EoSJYjDFUVVWhtLQUc+bMQWpqql8OvFMtRThawSiaXOr1ekyfPl3yXGpvb0dLSwvKy8uljjRRcIWFhflp9UMzFQRWKKRq3T3ZbDabJLjKy8thsVgQEREhE1xianAkgsu9hmsyv6eTARJYxKTG3dtKTCPU1NSgqKgIKSkpmDNnjrRdjGoFG2/ixm63Iy8vD52dnVi1apVUjBvINQx33VSF91xKSUmBy+UaVCAdFhYmiS0xfRQIpoLACsWCcY1GI0sx8ya4paWlsFqtgwSXKJxEwSV+z1wuFxbK7tQAAQAASURBVHp7e5GVlYVly5ZBo9FApVKBMYampiakpaUF7XkSniGBRUxaePsFoP8E6HA4kJ+fj/b2dqxcuVKqpRAJFYHlKUUopgT1er1fUoLuUIpwfIj+WlFRUUhLS5PV6xw9ehQ9PT0wGAyS4DIajX7rUJzIw55HQqgKLHd4E1xAXtMnTh2IjIyUxBbfRKFUKuF0OmE2m6FWq8EYg81mQ2lpKU4++WT09vYG86kRHiCBRUw63L2txJSg6GxuMBiwbt06jwIlVAQWnyJkjKG6uholJSUBdZMfzmiUBNbocK/XsdlsXk+u0dHRiIyM9JlomAoRrIn4/PiaPgCyqQN1dXWw2+1SEwVfMM8PobZarUFvyiE8QwKLmFR4KmQHgIqKCpSXlw9bsxQqAkuMYDkcDuTl5aG9vR3p6elSu3ggmIopwkCepDUaDRISEpCQkABAfnLNzc2F0+mEyWRCdHS0bEjxWJgKAisUarDGi06ng06nw7Rp0zyOeRKPa1VVVYiIiIDBYIDFYvGJwPr666/x1FNP4dChQ6ivr8e7776LLVu2DHmbL7/8EnfddRfy8/MxY8YMPPDAA7j66qvHvZbJAgksYtLgyduqr68POTk56O3tHZGzeagILEEQ4HQ6sX//fuh0OmRmZvp9wLSnNUylFGGwn4/7ydVsNg8a6cN3KIqO4iNhKgisiZAiHA2exjw1NjaiuLgY3d3d+OCDD/DII48gJSUFFosFP/zwA1auXDlmoWk2m7Fs2TJce+21uOCCC4bdv7KyEps3b8ZNN92EnTt3Yt++fbjuuuuQlJSETZs2jWkNkw0SWMSER/S2cjgcspRgc3MzcnNzERMTgxUrVoyoviUUBJZYtOpwODBr1iykpaUF7eTIe4VNBR+sUEEQBBgMBhgMBsyYMUM2pLipqQmlpaXSCBdRcA0lwKeCwJrMz4+h//3TaDTQaDRYunQpFi1ahDVr1uD555/Hl19+iTPOOAOMMZx00km46KKLsHXr1lE9xllnnYWzzjprxPu/+OKLmDVrFp5++mkAwMKFC/HNN9/g//7v/0hgHYcEFjGh8ZQSZIyhuLgYNTU1WLRoEaZNmzbig2+wBZZYhN/S0gJBEDB79uygrWWq2TSEMvyQ4tTUVNkIl2PHjqGwsFAyuBQ7FPlRSZNdgEzGCJYIgwNM+QoE581wOp2yovfVq1dj48aN6OrqwieffIKsrCx88cUX6Ozs9Pu6Dhw4gA0bNsi2bdq0Cb/4xS/8/tgTBRJYxITFk7eVxWJBdnY2XC7XmMbdBFNgdXd348iRI9DpdEhPT8d3330XlHWITLUU4USCH+Eye/ZsmcEl77ckCq6pILAmQw2WOwy9YKpfA4IdcEImsETEblSlUon09HSkp6cHZG0NDQ1S/aBIQkICurq60NvbC51OF5B1hDIksIgJB+9txaew6urqUFBQgOTkZMybN29MB1yFQiFFwwIFYwzHjh1DUVERZs2ahdmzZ8NqtUoDY4N1YqQi94mDu8Gl6LfU1taGwsJC2Gw2lJSUIC4uThrpM5kiPpMxgsXQAaa+HVBkA44rAXgWWBaLBXq9PhhLJIaBBBYxoXC5XHA4HLKUoNPpRGFhIZqamnDCCSdIpn5jIdARLIfDgYKCArS0tMh8ufghscEUWGO5jgg+vN8SYwz//e9/ER0djZ6eHhw7dgwul0vWoajX6yf0ezrZIlgM9WCqJ/vFFQCB9ZuIDhXBCjSJiYlobGyUbWtsbERkZCRFr45DAouYEPDeVqLoEAQBXV1dyM7Ohkajwbp168Y9ikSpVEqu7/6mu7sbWVlZ0Gq1yMzMlK1dPNkF85c5H6VyP/lOxgjWZHs+IuJ7l5CQgIiICDDG0NPTg/b2drS2tqK8vBxKpVJKJ0ZFRU24E6TL5ZLVnE1kmFAKpr4ZYHHcxv5aTE8CS5x3GGgyMjKwZ88e2bZPP/0UGRkZAV9LqEICiwh53AvZxRNGVVUVSkpKpLSaL36BByqCJRYmp6amYvbs2YNEFB/BChaiiHK5XKipqYFCoUBsbKyUjpisgmQywkdCBUFAREQEIiIiMHPmTLhcLnR1daGtrQ319fUoLi6GVquVCa5AjfQZK5MlRciEQ2DqOwCh2+0K7xEsi8UipYbHQ09PD8rKyqT/V1ZWIisrC9HR0Zg5cybuu+8+1NbW4u9//zsA4KabbsLzzz+PX//617j22mvx+eef46233sJHH3007rVMFkhgESGNJ28rm80mzePztfmmvwWW0+lEQUEBmpqasGLFCsnV2x3xZBhsgeVwOPDDDz+gr68PWq0WR48ehUqlkiwBxO1EaDNUqln01zKZTAD609adnZ1oa2tDVVUV8vPzodfrJbElDigOJSZDitCl2Aeo7gOEPoDpAKG5/woWBwGRALxHsHxRg3Xw4EGceuqp0v/vuusuAMDWrVuxY8cO1NfXo7q6Wrp+1qxZ+Oijj3DnnXfi2WefxfTp0/GXv/yFLBo4QutbQhDH8eZtJY67iYyM9DruZjz4U2D19PQgKysLarV62HQmnyIMFqLRZVJSEhYuXAilUgmlUonOzk5UVVWhq6sL3377bciffEfDRK5DGorR1PKpVCrExMRI9YA2m03qUOQHFIvvudFoDHr0aKJ3STLFW4Dy7/3iCgBYIiBUHr88YNXidDoHHfN8lSI85ZRThvxBt2PHDo+3OXLkyLgfe7IycY+ExKTF27ibsrIyVFZWYt68eZg5c6ZfDqj+Eli1tbUoKCjAzJkzMXfu3GFPSMGMYDHGcPToUVRXVyM8PBxLly6FxWIBMDDA2Gw2QxAELFq0SOpWKykpQV9fnzQ7TZynN5FPfJOF8TRLaDQaxMfHS80j4oDitrY21NXVweFwwGg0SoIrIiIi4O/5RE0RMjAw5QuA6hXAtRRAzfFruIkTLrnACpUid2J4SGARIYXL5YLNZpNFraxWK3JyctDX14c1a9YgMjLSb4/va4Eldjg2NjZi+fLlI66VEIv4Ax3BcjgcyM3NRWdnJ2bNmoWOjg6PJ0txm1qtlp18e3t70dbWhra2NtTU9J8seLfx0Yx3IXyDKNJ9JUD4AcWMMVgsFklwVVVVAYCsQzE8PNzv7/lEFFgMDjDFC4Dqb8e3cJEpNiCixA5CgGwaJhoksIiQQEwJil2CorhqampCbm4u4uPjsXLlSr+nn3wpsMSUoEqlQmZm5qg7s0RX+kAhdjWGhYUhMzMTzc3NaG9v97ivty5CnU6H5ORkaXZad3c32trapPEuWq1WMsiMiooKqc6vyVq0760T1BcIggC9Xg+9Xo/p06fL3vPm5maUlZVBpVLJCubH2+nriYkmsPoNRO8BBN5x3c5d7uV2HjqCFawuQmJ4SGARQcfbuJuioiIcO3YMixcvxrRp0wKyFl8JrLq6OuTn5484JeiJQEawxPWmpqZizpw5UgRtKIYTJIIgIDIyEpGRkdJ4l46ODrS1taGyshJ5eXmyWh6TyTShTpITBX8KLHc8vedih2JtbS2KiooQFhYmvee+EtkTSWAxdB43EM0CXLO4azoGLipauBsMHcGiFGHoQgKLCBrevK3MZjOys/sN9jIzMwMa/h6vwHI6nSgqKkJDQwOWLVs2btNTf0dVXC4XioqKUF9fP2i97j5Y4x32rFQqZcXTvNt4QUEBHA6HLLVkMBgCnk6cjOnLQAosd0R/raioKAD9KWh3kW0wGGQieyzdgBNFYLlQD6hvARQV/RuEuv5/mYK7rAWEpuOXYyFw9VieuiUpghW6kMAigoI47qakpAQAJB8rsRh8xowZmDdvXsAPmuMRWGazGVlZWVAoFGNKCbrj7wiW1WrFkSNHwBhDRkYGwsPDBz2+P4c9u7uNWywWqX6rsrISCoVClk70R2ppKhBMgeWOSqVCbGysZE9is9nQ1taG9vZ2FBcXo6+vD5GRkdJ7HhkZOaJjwESwaWBCKaB6YEBcsfgBIYVETmBN89hBCPjXpoHwPSSwiIAjRq3EsTcul0vyh2pubh5VMbivGavAamhoQF5eHqZPn+4zYejPCFZrayuysrKQkJAgWTC4E8hhz3wtz4wZM+ByudDZ2Yn29nYptaTT6STBNdHtIAJJKAksdzQajSSygYEmifb2dtlIHzEK5i2qGeo2DUw43J8WZMncxlguUhU9ILDANfG4BtKDwGCBZbPZYLPZKIIVotARiggYfEpQDOmrVCp0dnZi//79CAsL88m4m/Ew2mHPYoqtrq4OS5cuHTRdfjz4I4LFGENFRQUqKiqwcOFCTJ8+fcjHD9awZ9EOIioqCmlpabDb7VJqSfRiEiMdk3F4sS8JZYHljnuThNlslgSXGNUUPxfiSB/xexKq779L+AJQ/xoQbADjI018hJsz62UDp2WBi2CJjUD88zSbzQBAAitEIYFFBARv3ladnZ1oaWnBnDlzkJaWFvSTwGgiWBaLBVlZWQD6a8XcU2y+WIsvRYzdbkdOTg56enpGbHfBn5z51yXQ75NarUZcXJwU2ezt7ZXqt8RIh9ipNlY7iMnaRSi+b8H+bo0WQRBgMBhgMBikkT5ih2JjYyNKSkqg0WgQHR0tmRKHGv0Gonv6xRUAgD+28D/k+LVbuTuQCyzGmCyCJfrT+frYQ/gGEliE3/E27iY3Nxft7e0wGo2YPXv28HcUAEYqsMSUYHJyMubPn++XX8++jBJ1dXXhyJEjMBgMyMzMHFHnViBThKNFp9NBp9Nh2rRpHq0B1Gq1rH4r1Gfp+ZPxmIyGEgqFAkajEUajEbNmzZK6UkUrkcOHD0Ov10vRLZPJFDQbkH4D0e2A6mXANYe7poe7zM8b7Bi4qGjl7kjeQQhAJrDMZjPCw8NDNno31SGBRfgNb95Wra2tyMnJgclkwty5c9HU1DT8nQUIpVIp/VL0VutRXFyM2tpaLFmyRKod8Qe+ShGKg6XT0tJGFSXkBZa7mPJ3inA0eLODaG9vl2bpiZ1q0dHRMBqNXguiJ4MQcWeyCCx3xK5Uk8mE6upqrF27VkoplpeXo7e3FxEREZLgGup99yUu2AHVY4Byd/8GoWHgSqGeu3x8OxMGtjMNAHF7DASYpN09CSyyaAhtSGARfsGbt1VZWRmOHj2K+fPnY8aMGWhoaBhVzZO/EX8JeupKslgsyM7OBmPMLylBT2sZj4jhXeSHGiztjaFOyqF8wna3g+A71QoLC2G326XRLtHR0UGxgwgkk1VgiYg/QjQaDcLDw6U0cl9fn8f3XRRc/qjbY+gFlI8Byn8f3xAFCMfNepkJEDqOX44GhLbjt0rgxFYSoKg6fjlVdt98BkCELBpCGxJYhM8Ro1b8uJve3l7k5OTAbrdj7dq1iIiIANB/MpwIAquxsRG5ubmYNm0a5s+fH5BfwuOJYIn1YYIgjNkyIpRThKOB71Tj7SDa29tx9OhRqXDabrdPSiuIqSKw3MWSVquVjfThOxSrq6vBGJMVzOv1+nG9TpKBKGzcxjhOYMVzAit+QGCxGC7KZQIgCix5w4w3iwaqvwpdSGARPkP0thKLTUVx1djYiLy8PI+WAKPt2vM3vMAS/y0pKZEc5ZOSkgK6lrGImObmZuTk5CApKQkLFiwY86/0YHYR+gtPdhCi03hdXR3a29vR2dkpG+0y0e0gpqrA4hEEAeHh4QgPD5dG+vT09KCtrQ2tra0oLy+XRvrwHYojhaEeTDQQda3kruCiS7IOQl4UcaKe6yAcqcCiCFboMrGPHETIwNsvAAPRl+LiYtTV1XmtV1IqlQEfaDwU4onI5XKht7cXWVlZcLlcyMjICLiZ32gjWHwK1hfjhfxtNBoKKBQKmEwmmEwmOBwOMMYQHR2N9vZ2WR2PmE4cqfFlKDEVBNZo3xNBEBAREYGIiAikpKTIfNfq6+tRXFwszc0UBZe3RgkmlIIpnxwwEOU7BfmXXfYe8N8r/gdm38DuJLAmPCSwiHHhydtKEAT09PQgOztbcjX3FsYOtRShIAhQKBRobm5GaWkpEhMTsWDBgqC4RI8mgmWz2ZCdnY3e3l5ZCnY8uAss97VMxAjWcCgUCpkdhNVqldzla2trJTsIMcIVHh4e8uKFBNbw8P5awMBIH/dGCb5DUaVSgQmHwNR39NdaSfCdgmYvl/l9ugYuCvw+JLAmOiSwiDHjzdtK7FobyaDjUEsRulwuMMZQXFwc0CHTnhhpBKuzsxNHjhyB0WhEZmamT1Na3kwqJ2qKcDjcn2dYWBimTZsm2UGIaaWWlhaUl5dDrVbL/LdC0Q6CBNbo8TTSp729He3t7ZLR7YzUUsya9zIABwRhIPIk7xps9nKZ65yWHNwBCJ0Dl0cYwaIxOaELCSxiTHjytrLb7cjPz0dbW9uIu9bEFGEonASsVqtkHLp06VK/WjCMhOEiWIwx1NTUoLi4GHPmzEFqaqpPX8OpkCIcDe5pJafTic7OTrS1taGmpgYFBQVSlEMc5xMK8/FEi5TJSiBc3DUaDRISEqRJDX2OXVCFb4cgMPRZTdCGdQAAnM4IKJXH/a2YgStk13OXjQNCisUCQsvxy0oAYmchqAZrEkACixgVoreVOENQFFcdHR3Izs5GeHg41q1bB61WO/ydYcDTJdjDWsXC8ISEBPT29o54/f5kqAiW0+lEfn4+WlpakJ6ejujoaL88/mQrcvclSqVSilwBA1GOtrY2FBUVwWazSXP0xHE+wRCmofDjxZ8EckyOaCCqVn8HCP2ff61mGkSjUFufCbrwfoFl7TUiLPx4KpAlAkL58csJnMCKGhBY4C4zFQD5d9qTwCIfrNCGBBYxYrylBCsrK1FWVjamKIp4wPB08AgELpcLZWVlqKqqwqJFi5CcnIyvv/46JArvvUWwzGYzjhw5ArVajczMTL9ZCwz3Pk42gTXe58NHOXhbgLa2NlRVVUEQBKloWhznEwhIYPkGBgeY6tF+A1FnOnfNwPuo08YCqDn+v0gAtQCAri6GSJO43nAMLJf7DDAjJ7biIUD+nDwdIy0WS9Aj7YR3SGARI8KTt1VfXx9yc3NhNptx4oknwmQyjfp+3W0RAonVakV2djbsdjsyMjKkX4KjmUfoTzxFsEQ/runTp2PevHl+PbHwUSpPNViEd9xtAfg5eg0NDSgpKUFYWJisS81fY11IYI0fhl4w1UOAcu/xLZzXlawLcOB1DtNywks3EGXq6uyCqd8DF3Ybg1r6fcTVUrH4QWvwFOWnFGFoQwKLGBLe24ofd9PS0oKcnBxER0ePeLadJ8SuvUAXuovrj42NRXp6uqwwPFQK7/kIlsvlQmlpKaqrqwNWH0YpQt/hPkdP7FJra2tDRUWFzA5CHOviK9FAAmt8MHSCKX8BCGUDG0XzUACyjkDBwm0fGNqsVg0MczaaBoRXr9UqCazeXjt0osZyq78C+jsb3UsXSGCFNiSwCK+4XC44HI5B425KSkpQXV2NhQsXIjk5edwH70BaNfBeUQsXLsT06dMH7RNKESzGGPr6+pCdnQ2bzSaLtAXq8fn/80xGgRUoIeLepWa1WqX6rbq6OjidTphMJklwjcdl3OVykcAaIwz1YKrbALQCiuN2CkzheaYgIO8UVLR4vCxwVgyRkQNii7kGvk9NjUBvVyWioqIk7zVPz5MEVmgzeVtLiDEjFrLbbDY4nU4pytTb24vvvvsOLS0tyMjIwPTp031y4A6UwLJarfjhhx/Q0NCAtWvXehRX4npCRWD19vZi//790Gq1WLt2bUAPpuJ760lITeYTdjAICwtDUlISFi9ejHXr1iE9PR1RUVFobW3FwYMH8e2336KgoAD19fXo6+sb/g45KII1NhjKwFTXAEIlgDjumkRAOH68YkZAEAvZdYDQevyydsCKgb8MDIzLAQAMRLzC9QMWH1pNCsxmM3Jzc/Hf//4X2dnZ6OnpgdPplH0ffWnT8MILLyA1NRVhYWFYs2YNvv/++yH337ZtG+bPnw+dTocZM2bgzjvvhNVqHfI2Uw2KYBEy3MfdCIIAQRDQ0NCAvLw8v8ziC0TEqLW1FdnZ2YiJicHKlSuH9IoKhQgWY0wa4bJgwQLMnDkzaCdJTydoShH6D0EQYDAYYDAYMHPmTMllvK2tTfKY0+v1UgfjcHYQJLBGD8MRMMVfOJHEj7yJHvCuYvFcR2DicTGG/qHNwtHjl+MA4djxy0q5wOJ9rzixZTLOQ9SSJZL3mjg3s7q6GnV1dfjggw+QlJSEtrY2nwisN998E3fddRdefPFFrFmzBtu2bcOmTZtQXFyM+PjB9WCvv/467r33Xvztb39DZmYmSkpKcPXVV0MQBDzzzDPjXs9kgQQWIeHJ28rpdKKwsBCNjY1YunSp5APjS/wZwWKMoby8HJWVlViwYMGIom7BFlgOhwN5eXno6OhATEwMUlJSgrKOoSJYQ22fqITq8+FdxmfPng273S6lE4uLi9HX1wej0SgJLnc7CBJYo4Phc0DxG0CYz23l75+rg+KFFyK5y0buMr9PNIDjaUQmQOZ7JXCO7sdrsHjvtaamJkyfPh1hYWHYt28fdu/ejaqqKmzduhVnn302Tj/9dJx22mljqs985plncP311+Oaa64BALz44ov46KOP8Le//Q333nvvoP3379+PdevW4fLLLwcApKam4rLLLsN333036seezFCKkJCiVmJKUBRX3d3dOHDgAHp6epCZmekXcQX4T2D19fXh4MGDqKurw9q1azFjxowRnWiCKbB6enpw4MAB2Gw2pKSk+K2zbCS4C6yh6rGIwKFWqxEfH48FCxYgMzMTa9asQUJCArq7u5GVlYX//ve/yM3NRW1tLSwWCwmsUcCEXYDiHkCwQT7Cppfby3PXoHxQMx+74Ic588LLNJBqBAC0cvsNPtY6nU6oVCqYTCY89NBD+O9//wuj0YgHH3wQMTExePrpp5GcnIza2tqhnuIgbDYbDh06hA0bNkjbFAoFNmzYgAMHDni8TWZmJg4dOiSlESsqKrBnzx6cffbZo3rsyQ5FsKY43rytqqurUVxcjNTUVMyePduvXTr+6NprbW1FTk4OoqKisGLFilGNjwmWwKqvr0deXh5SUlIwd+5cHD16FGazefgb+omhTsqUIgwdRDuI5ORkKbXc3t6OxsZGlJSUQKlUQqVSoampya92EMHCNwKLgeE1QPEct40vXuciTejmtnvuGoRg57bz6VtuJiszDXQjsijusgJAzKAVuvtgMcZgNpuxceNGpKWlAQDa29uleYojpaWlBU6nc9AP6ISEBBQVFXm8zeWXX46WlhasX79e+oF+00034f777x/VY092SGBNYVwuF2w2m8zbym63S+mplStXIiZm8Bfd1/iyqJwxhoqKClRUVGD+/PkjjlrxBFpguVwuFBcXo7a2FsuWLZNqHkYz7NkfTLUUITDxI3OCIEh2EKmpqXA4HCgtLUVHRwcqKyuRl5cn2UFER0f71A4iWIx/CoQDwBMA8gY2sRhAyY2wkRWpN3KXuaiTTITxwos/lvCnXN73ysRZP8RC8HBqdhdYNpsNDodD1vgyWnE1Vr788ks89thj2L59O9asWYOysjLccccdeOSRR/Db3/42IGuYCJDAmoKIXYJ2u13mbdXe3o7s7GxERERg3bp1ARtc66sUoc1mQ3Z2Nnp7e7FmzRpERkYOfyMPBFJgifMPnU4nMjMzER4+8At3pMOe/QUvsERX8vj4eGg0Gtl1E12UiExGwahSqRAeHg6n04klS5agr68PbW1taG9vR35+PhwOh2QHER0dPS47iGDhcrnGEZWzAvgNgK8BLOO2xwAQrRUSAUV1/0VZpClswJaBqdzsGvh6Ks6UlP+IMf74yostz6UY7gKrp6e/e3G8ncWxsbFQKpVobGyUbW9sbPRaz/Xb3/4WP/3pT3HdddcB6J/dajabccMNN+A3v/nNhBftvoIE1hTDW0qwvLwcFRUVmDt3LlJSUgJ6kPVFirCtrQ3Z2dkwmUzIyMgYVxokUEajYmdjXFwcFi1aNOhXeKhEsFpaWlBQUAC1Wo2SkhIYDAYYjf21JMGeIUkMDz/sWavVIikpCUlJSVKKSSyYr6yshFKplEb5REdHh8RMzuEYc4qQdQL4PSB8fXwDfx9cKg8mAKLAiuMEVuJApyASAIGvfeIjW1yaX3Bw+/D1W5zY8iCwGGODvmsWiwWCIIx75JJGo0F6ejr27duHLVu2AOh/Tfft24fbbrvN420sFsug11xc22T8oTJWSGBNIfiolWi/YLVakZOTA6vVitWrV0snzkAynggWYwyVlZUoLy/HvHnzfGJnoFAoYLfbh99xjPBrHqqzMdgRLJG8vDwsWLAAUVFREAQBbW1taGnp/3X/3//+V3ZCDg8Pn3ARkMmOtygjbwcxY8YMmR1EbW2tZAchvr8mk2lUtYyBYkwCizVAYb8dLpV1QOcIA/5ijBc/sq5B3hKBO1ayiIH7YUa5/YLM9Z1LHQreiuU9F7gDkAks0QPLF9+3u+66C1u3bsWqVauwevVqbNu2DWazWeoqvOqqq5CcnIzHH38cAHDuuefimWeewYoVK6QU4W9/+1uce+65I/7B5c0AdzIdP0Lv20L4HLEIsbCwEEajEQkJCRAEAc3NzcjNzUVsbOyw3lD+ZKw1WDabDbm5uejp6fGpOPRnitButyM3NxddXV3DrjmYESyHw4GcnBwAwIoVKxAZGQmbzQaNRoPExERER0ejqakJK1asQGdnJ1paWlBeXg6NRiOJrclYUD0RGWkal7eDACDZQbS3t6O0tBRWqxWRkZEyO4hQSAWNWmC5yqGw3w6gGRD42/GiiO8a5KNO3P5eOwVNnDeWyk1scalDcI/BiS0BIxNYPT09PjMevvTSS9Hc3Izf/e53aGhowPLly7F3716p8L26ulr2Gj/wwAMQBAEPPPAAamtrERcXh3PPPRePPvroiB8zFD47/oYE1iRH9LZyuVwwm83QarVgjKG4uBg1NTVYtGgRkpOTg7pGpVI5andqsV7MaDSOaxaiJ/wlsLq7u3HkyBGEh4cjMzNz2Bq3YHXq9fT04MiRIwgL6z9peDIyFE/YYrpw5syZcDqd0ny9yspK5OfnIyIiAjExMYiOjkZkZGTI/zoN9fWNhbHWyYl2EGLThViH197ejpqaGgCQ1W/pdLqgvH6jEljOLCgcd0FANxji5KNtwNcgcVEnXhTJugb5gc981Ib/vkRB8r0CIPO94rsRebHlYdAzP1FDxGKx+HSyw2233eY1Jfjll1/K/q9SqfDggw/iwQcfHNNjff755zhy5Aji4+Oh1WqlTlidTgedToewsDDpX41GA61WC41GE5IR1KGYWKslRo3T6ZS8rVQqFXp7e/G///0PQL+Xia/GLIyH0dQ8McZw9OhRlJaWYt68eX6pF/OHwKqtrUVBQQFmzZqF2bNnh6wfV2NjI3JzczFjxgzMmzcPn3zyyZCjcvjrlEolYmJipM5Tq9WKtrY2tLW1SSfkqKgoSXCJAo7wL75qRNDpdEhOTpbsILq7u9HW1oampiaUlpZCq9VK6cSoqKiANcmMVGAJti+gsL8FqI4LG2FA/DDEAgrRtV0l7xSEt65BbsizrFOQTykauUJ499Qhd1+855aXFKF76s1sNsuaYiYS27dvx+7duwdtFwRBElTin06ng1arRWRkJDo6OvDMM89g48aNQVj16CGBNckRf/WI9Vb19fWYOXMm5s+fHzIh2pGmCMWUYHd3N1avXg2TyeSX9fiyyN3lcqGwsFAKu8fFxQ1/o+MEMoLFD8FesmQJkpKSZGvwdoIean1hYWGYNm0apk2bJp2QW1tbUV9fj+LiYuh0Olk6MdjF8pO1ONcfw54FQUBkZCQiIyORmpoqi15WVVVJ0UtRcBmNRr+9vyMRWIq+d6C0/D84tcsGSqUEXpxEAxCtGBIAhTjaxgQoPcwXBORiifE1m/xauAJ0WerQIBdovMXDCAWWL1OEgeaXv/wlTjvtNNjtdnR2dqKrqwtdXV3o7u5GV1cXenp6pD+LxYLW1lZUV1dLHm8TBRJYkxxRLBQWFqKjowOxsbFYuHBhsJclYyRF7h0dHcjKykJkZOSI0mvjwVeRo97eXmRlZYExhszMzFF3+wSqyN1utyMnJwdmsxlr165FRESEbA3e1jYa+BPyrFmz4HA40N7ejtbWVpSUlKCvr0+WbjIYDJMyXRcM+C5Cf+EevbTZbFL0sqCgQLKDEAWXL9/fIQUWY1BaX4LS+goAQJCZgfKPz383TQCOCyzEQeoIZImAUHX8sgLyNCJvCMwfy/jSBX6eYRQ3JNpNbMFzitBTBGuiCqyMjAxkZGSM6bYT6YcQCaxJTnd3N3744QdoNBrMnDnTr91xY2UogcUYQ1VVFUpLSzFnzhykpqb6/cTrC+PT5uZm5OTkIDExEQsXLhzTCS4QRe5iXZher/dob+EtijacCelwqFQqxMXFIS4uTuaz1dbWhqNHj0KpVEpiKzo6OmDppslIMLzKxGaIxMREMMZgsVhk769CoZAil+NNF3sVkMwBVdvzUCj+MbBJ0cVFsPgaqpF0DfK+elFu6cIO7jqunpR5sWKA+/BoUWzFQMDgelJPdihiF+FExOVyDRrBJVpRqFQqKeviiYn0w4sE1iRHpVIhOTkZs2bNQlVVFXp7e4e/UYDxlpLjO+5WrVoVMJfi8USw+OHS420g8HcEq6GhAbm5uUhNTcWcOXO8tkwPJaJ8IQAFQZCKXKdPny6zC6ipqUFBQQEMBoNUuzUZ3McDSbDNYAVBgF6vh16vl+wgurq60NbWhrq6Olm6WOxiHE0xs1hjKsNlhabxfgiOOvk8Zr7gXFa8PhDZYoK3aDrvVWUcEFju0SzwvlfeUoe8vxgvtjybjDocDo8Ci482TySG+/6K5ymlUgmFQiH9TTRIYE1ywsPDpTlV/hqqPF48RYw6OzuRlZUFg8Hg95SgO2MVNjabDTk5ObBYLONykhfxVwSLMYaSkhLU1NTghBNOGHKI93ARLH/A2wXMnj1blm7Kz8+H0+mU0okxMTE+7V6bSL+OR0qwBZY7CoUCJpMJJpMJaWlpUrq4ra0NZWVlkh2EGN2KjIwc8uQ6KEXo7IS2/k4ordlwhi+VNjMhGgIfaRJaBi6D2w6+NopLKcq+Bnz9lns0ixdbnq0Y5F2HfMTM83dxskWwPNHa2or9+/cjKytLGlKu0Wig1+sRHh6OsLAwMMZwxRVXTJjnTQJrCqFUKuFwOIbfMcDwwo8xhurqapSUlGD27NmYNWtWwE8OY0kRdnZ24siRI4iMjBy3k7yIPyJY4jghq9WKtWvXDlvD4a8U4WhwTzeZzWa0traipaUFZWVl0Gq1snTiRGvl9jehJrDc4dPFQH/0QhRctbW1cLlcsu5EdzNbPkUo9DVC03A/lPbs/usUA99DpoiCKKQYBjr6GBSQWzTwhey8cOKOncxbNEsDCPwwaN73ihNrfNch48Xj4PorwHsNVjCMof1BZ2cnfv3rX+PVV19FREQEurv7X0O1Wi2VtYjniXPPPZcEFhF6qFSqkI1giS7z4qDpQKYE3RlNipAxhmPHjqGoqMjngtDXEayuri4cOXIEERERyMjIGLEQ8baGYPh08e7jKSkpsu61iooK5Ofny8wwR+O9NZGKZ0dDqAssd0QvJLH7tKenB21tbWhubkZZWRnUarWsfksaVm+uQFjeL8FiuAiUgntPBe6kLMRgwFg0DlDU919kBkDBiyLew4oXSPzr6RbNkok13veKWxfj6rR4k9Eh5hC6R/HMZnPQPQx9xQsvvIBXX30Vt956K6688kqcccYZ2Lx5M8477zzs378fr732Gn70ox/hxz/+8ag6sYMNCaxJDn9gDdUUoViDtX//fuj1+oAOmva2npEILKfTiYKCAjQ3N2PlypVSB5Wv8GUEq66uDvn5+aPy4RLX4O8arPHAd6/NnTvXo/cWH92ait5bE01g8QiCgIiICEREREiCWqzPq66uRkFBAQCgtXwfYrqeh8JlhovZJP3DFPaBonY+miW4m4EeF1iIH4hAsUhAyaf7+MgUdxyVRbMiBzy0WKRbnVcHd5nvOuSL4r0LLPcfRBO5i9CdHTt2YOXKlXjuuecA9HvozZkzBz/5yU/wk5/8BD/+8Y9x5pln4tZbb51QEeqJs1Ji3KhUqpBLETLG0NjYCKfTienTpyMtLS3oJ4ORCCyLxYIjR45AqVQiMzPTLyduX0SwXC4XSkpKcOzYMSxbtkxy5R4p7gKLr3cJ9vvkCXfvLbGYmvfeEovlTSZT0L23AkEgbBoCBd9dCvSnE8v3v4p5HW9BAQdsTAc1P+aGc15ngmsg7iTwKXz+u8sXjZsgt2Lo4K7zFs1y9706LrBYmHffK164DSGwJpNNAw9jDDU1NfjFL34BYMAcmz/2bNiwARs3bsRTTz2Fs846K4irHR0ksKYA4gc11CJYDocDeXl5aGvrP9gEo97KE8MJrKamJuTk5CA5Odmvhq18ndNYXhebzYasrCzYbDZkZGSMqW7BvdbF/bpgR7CGQhAEGI1GGI1GzJo1S5qt19bWhuLiYthsNhiNRqlYPpSfy3iYyBGs4dAd/QKz2f+gOD4vUBFmAp+Ws9mboT1eQ+5i5oHScsHzD03GF5/zFg1M5zYmhxdL/DGVP6Xy4icaQN3x+3Kv0+rgHse7wHKP6k+WIvfe3l6o1Wpoj79RfX19CAsLQ09Pj/S5dblcSEtLw1tvvRXMpY4aElhTCLEGKxQOuF1dXcjKyoJOp8PatWvx9ddfj35oq58QI0furxNjDKWlpaiqqpK5nftzHYDnDqLhEIvujUbjuAZ5h3qKcDTws/VE763W1lbJm0n0awoLC5tU3luh8H33OYxBmf0GlDlvoC95QGQImgFRw6CARjMghGy2FuiOfw3szk6oxK+U4K3Tj3//oyDvCOzgrvPWach3Bxq4QFcMpJSke2RrlEXukyGC5XA4MHPmTFRV9Zu42u12zJgxA4cOHZL2MZvNKCgomHC2FCSwphDiF9RTPj9Q8EXhYj2QeJIO5rp4PAkbvvsuIyMjIAe2sXbqiXMPfVF0P9SonIl80ua9t0RvpuzsbKmLVTyYi+moiey9NekElssJ5XcvQVn6MQBAoeCiUUquzkoZBYHrAgzTDdQ9udiARYPd0Qy1pKV4p3c+msUJJKZ1E0V8NGokI3MiAEGs+eIjW0YI8FxqMJkFllqtxqpVq/Ddd98BALRaLc4//3w88cQTuPfee3HGGWdgz549+PLLL3H11VcHd7GjJPhnM8Lv8ClCoP8XQzCEjMPhQH5+PlpbW2VF4YIgQBCEkElfugsscUyPyWTCihUrAvba8eHxkeByuVBUVIT6+nqsWLECsbGxPllDKHUR+guFQgG1Wi0VU3vy3hK71qKjo33qveVvJpPAYnYb8O3rUFZ/LG1TKQYc2RkvQpRGiGNueA8shjBoNP1iizElVKoBEdbX1watqIUYfzziR+lEAWgY+K8smsUbOXtLHfJiKxIQRIHl/fs62WYR8oSFheH666/HvHnzYLFYEB4ejptvvhkff/wxnnnmGTz55JMAgPT0dDz++ONBXu3oIIE1hRDdcIMhZLq7u5GVlQWtVot169ZJ+XaRUKoPEwWWw+FAXV0dSkpKMHfuXKSkpAT0RCWuYyQipq+vD1lZWXA4HMjIyEB4ePiwtxkJkylFOBrcvbd4q4DS0lJotVqpWH60zuOBxh/DnoMBs5hh+9fzUEdYZNtVAteFxwWNmHLgO8B7YEGIA4Qa6bKgqBu4L83AfXeb2xBx3GbK5VJACmCyCEA4LrBYmLwjUOZ7xa2L972SnXb5iFU0vOFJYFkslklRgyUIAtatW4d169YB6D+mzJw5E//973+xc+dONDQ0YNGiRdi8efOo57kGm9A9KhB+IdBChjGG2tpaFBYWDjmSxVcDln2BKGwKCgoCPqaHZ6QRrI6ODhw5cgTR0dFYsmSJzzvjJmOK0Bvenqe7VYBYLF9eXo7e3l7JeysmJgYREREh9dpMhgiWq7MNtn9uA2uuh7BU7v2k5tN6XLqQcelCuQcWP2EhEgMpOhWUioHUH38u7+zsRNRxFxa7XQ219PuQS/EBkPteccKLcalD2Y8SPg3p3ebFXWCJon8yRLA6OzvR2NiIefPmARiwp9Hr9bjhhhuCvLrxQQJrCuDuhRUoqwaHw4GCggK0tLQMm7IKpQhWT0//QdZmsyEzM3NQtC1QiKnToaJENTU1KCoq8luEjb8/9/ueTCnC0aBUKhEbGyt9nvlB1aHovTXRBZa9vhHOfz0N1tVvmSAoBz5zTKmEkqt7EmTRLK5BRTFwqmMCX7zOf7ejAGHAxV2lGhBbRuNANKy31yYJLFufFhrx7R3ke8VbPPC+V/yQae77MwqBZbVa4XK5JrTAEpuaDhw4gF/84hf41a9+hdWrV2P+/PmyY+5E/vySwJpiBMrNXUwJajSaEflEhYrAamhoQF5eHhQKBRYtWhQ0cSXizWzU5XKhoKAAjY2NfjE5He7xRaaiwHJHp9MhOTkZycnJcLlc6O7ulg0yDg8Pl8RWMLy3JvIJqq/0KLpe3wUDGxArAufO7tK4p4x43ysH53vFO7rzn1n+FBgJ2ZgczgNLoRgQbpFi3hCA3a6SBFZfnw7aMNH3yt2KoZO7zKc4B37sCqNIEVos/fcxkQWW+JnU6/Vobm7GDTfcgPj4eFxzzTXYsmUL5s6di+jo6An72QVIYE05AiFkxC62lJQUzJkzZ0TdV8GqDRPhDTmXLl2KgoKCkBAPnsxGrVYrjhw5AsYYMjMz/VqXMNTBbbJFsHzxXBQKhVfvraKiItjtdhiNRql+S6/X+/0EMlEFVu+RfLS/8gY0cXqZl6fAFY8z9x9AvJBR8EJmII3IeFsGma+Cm0mokp9D6LlTUK/n0o3MAHFMTl+fHtqw/kgVY0oIfOrQq8WDZ4HFGBsksHp6eqBQKIL+A3A8iJ/JjIwM7Nu3Dx9++CH27t2LJ598Ek888QTOPPNM3HDDDTjllFNgMBhCus7RGxNvxcSo4Q+u/nRzF0fHNDU1Yfny5aOaGTWWAcu+wmq1Ijs7G3a7XTLkLCoqComaMPcIUnt7O44cOYLY2FgsXrzY79GQ4boIiaFx996yWCxSOrGiogIqlUqWTvSH99ZEFFg9X32Hrp3vA4xBUCv5QA8E7j/Mbai6wDoHxBgnipiii9NoHdwt+GMhf18DHYj98LVVnEDjvhta7YDYUiqiIEbAbH3h0IZxAk32+Hzq0LPAEr///HddtGiYaO+rJ1QqFZYvX47ly5fjzjvvxO7du/HOO+/gm2++wd69e5GQkICbbroJV111FWbNmhXs5Y6KiWnsQowZf0Wwenp6cODAAZjNZqxbt27UAzmDlSJsa2vDgQMHJMNTsSsnVIruedPT6upqHDx4ELNnz8bSpUsDkmqaql2E/kAQBOj1esyYMQPLli3DSSedhEWLFkGj0aC6uhrffPMNfvjhB5SXl6O9vd1nn7+JJLAYY2h587/oenefJF4UGrfTFFcwzlQK7nIEBJlRKC+QBnyv5LVRA2KJyUbe8C7uBkDg6qb4aBY8+16pVAOpO416oPbUbg8HhIH3lYGLuHmpwfIksCZLgbuIGKXT6/X46U9/ivfeew9fffUV7r77bhgMBjz88MOYPXs2tm/fHuyljgqKYE0x/BHBEgcJz5w5E3Pnzh2TIWMwuhuPHj2KsrIyzJ8/HzNmzJCdhEJFYIn+YHl5eWhubkZ6ero0hy1Qjz8VfLBEAm3Dwc/V6+vrQ3t7O1pbW5GXlweXyyXz3hqr9cZEEVjM6ULjXz5G56dZiEgYEDSCSn48EVxcIbuKK2RXR0A4XkPFFKYB3yshCsLx1CGD3q3g3MvIG9kA5yg3Y1E+3cenIfnjxUA0TBAGhJBaGQ2xTowxBQSua7Gp0QmTsW9Q2k88XvPH1cli0cDj/hmdP38+nnjiCZx77rm4++678d1334XEMXk0kMCaArh3EfpKyDidThQWFqKxsXFMg4R5AlmD5XA4kJubi87OTpx44okwmUwe1xMqX+b8/Hyo1Wq/DZUeCkoRBg6tVuvRe6upqWlc3lsTYdizq8+O+m3vo+eHUgAAs9mkeJJC5fY5cw4ILMb7Xqn0A2brKiPEVFy/B9bxSJFghDwt18Fd5l3c+deLixQxg9vQZq5rkHHCT/ad4VOP3FgfmMCLtZoaM/LzvoVer5feY5PJJBke89+3yTKHUETsmLZarTh27BgqKyvx2Wef4V//+heOHTsGtVoNjUaDGTNmBHupo4IE1hTDVzYNZrMZWVlZUCqVPim0DlQNVnd3N44cOQKdTofMzEyvNS+hILBaW1thtVoRGxuLlStXBu0kOVQEZLJFsEKFkXpviYJrKO+tUI9gObp70fDn/8B8XFwJaiUEvvjcLRMuOLgaKAX3o0w2JocTRQKfShsQJQxhbhEoXnjx331+pqBpiGgWL7x43yv+tefvKwIQjt+e6bEqfZ2sKaKkpAR9fX2SkOrs7ERkZCQEQfBpivCFF17AU089hYaGBixbtgzPPfccVq9e7XX/jo4O/OY3v8Hu3bvR1taGlJQUbNu2DWefffaYHr+7uxslJSUoLCzE/v378d5776GhoQFarRbTp0/HVVddhUsvvRSnnXbahCvqJ4E1xVCpVOjt7R1+xyGor69HXl4eZsyYgXnz5vnkxB+IFKGYyhzK8FQkmAKLMYaqqiopajFz5sygiauplCIM5ecylPdWdXU1BEGQ0okxMTETxkfI1tyFow+9AxV33hQ08sJ1hUxgMcA+cPwSBKfUCMiPyWEKTmzJPLD4CLDJTWBx9VAyF3Z+AdywYWaSdwR6G5nD1VyBeRuZ019/xTdFAP3v87Fjx2CxWJCdnY2srCx8+umnPitwf/PNN3HXXXfhxRdfxJo1a7Bt2zZs2rQJxcXFHjMSNpsNZ5xxBuLj47Fr1y4kJyejqqrKYxZgOMTOyCeeeAJ/+tOf0NPTg4iICCxcuBAXXXQRNm/ejE2bNo37OQYTElhTjPEIGafTiaKiIumXznhSgu4oFAq/dTfyM/pG2t0YLIEl1lu1tbXhxBNPDLpdhPtBnF9LqJ60pwKevLdaW1tRV1eHoqIiKc0UHR0dsqNyrNUtOPrQO7C3dEM5yyRtV2jkpyVZNEuthsDNCBQE+4DTAv8bRMn9R+aBxd83n/pTAQreJJQXXvz3zz2a1TFwe5nJKF+8zhfCe4lmeekg1Ol0iIqKQnt7O0488URER0ejsbER77zzDurr65GWloYNGzbgjDPOwOmnnz7q+sxnnnkG119/Pa655hoAwIsvvoiPPvoIf/vb33DvvfcO2v9vf/sb2trasH//fqiPd3CmpqaO6jFFxM9kfn4+li1bhk2bNmHt2rXYsGGDtI94vAnFz+9IIIE1BfCFk7vZbEZ2djYEQfDprDt+XX19fcPvOEp6e3uRlZUFxtio1h0MgWWxWHDkyBGoVCrJQX44o09/Q12EoQ/vvZWWlialmVpbWyW7kaKiIsTFxQXMe2s4zPnHcPQP78Jl7v/OMwcnmjQqudk5FwESdPIUkcBHmvgxOYKTMxm1wTNuA5wF3mSUF0j87floFl8DFQ25SWkHt0i+tsvLTEIvHlhA/48uhUIBQRCwZMkSPProo4iIiEBVVRWuuOIKfPbZZ3jkkUeQn5+Phx56yOv9uGOz2XDo0CHcd9990jaFQoENGzbgwIEDHm/z73//GxkZGbj11lvx/vvvIy4uDpdffjnuueeeEXc1u1wuqa4MAB566CHMmTNHSoU6nU7p+lCvHRwOElhTjLE4uYvu5snJyZg/f75fPvT+qMFqbW1FVlYWEhISsHDhwlHZGgRaYLW0tCA7OxtJSUlYsGCB9Bp7MhoNJKLA6unpQUlJCfR6PeLi4qSan8kmsIItPHyBu/fWF198IUVBKioqoFarZd5bajcvKX/TeaAMLR8clsQVAMDOOZqrFTKBJXD1UAqtW/qQK0yXjcnhRA1DLye2+GOfe+rvuEBiCjcrB2+dgnynYeSAQGPh8tvwtVmymYT8Mxn5mByg/wevyWTCWWedhbPOOqt/ZaM8XrW0tMDpdCIhIUG2PSEhAUVFRR5vU1FRgc8//xxXXHEF9uzZg7KyMtxyyy2w2+148MEHR/S4CoVCNsh+2bJlsuuVSmXApx34CxJYU4zRpAjFX751dXVYunTpoC9isNY1HIwxVFRUoKKiAgsXLsT06dNHfR+B6mpkjKGyshLl5eUe1xoKEazu7m5UVFQgJiZGMmUVr2tvb4fJZJpwxadTjWnTpiEsLAwulwsdHR1oa2tDVVUV8vPzERERIdVuRUZG+jVq0PqfHBzbvg/6hUmy7YwXWCr5yVWWEtTKT1lKxteT8qKG96riDEf5aJIsXcdHtk2Aopnbje8U5AUS/zrx0bBI+VrApw75aBZvCzHyMTlAv8ByH48ViGiPy+VCfHw8Xn75ZSiVSqSnp6O2thZPPfXUiAXWfffdB7PZjLvvvhszZszAa6+9BqVSCaPRCL1eL/2Fh4dDp9MhLCwMOp1OiuhPJEhgTQHG4uRusViQlZUFAMjMzPR5StAdXwkau92OnJwc9PT0YM2aNYiMjBz+Rl7W429h43A4kJeXh46ODqxevRpGo3HQPsGMYImRq+7ubixZsgSRkZFQqVRQKBTo6upCXl4e2tvbUVdXB4PBIHW0GY3GCR/anyy417B48t4Si+Vzc3Nl3lsxMTE+G8PEGEPjv/6Hxp3HU09M/t1i9gHholC7fXZcnPjS8EKDQcl4UcXP++PH3HRwt/E8B1BupRAJgBNYsk5BrtNQ8Ox7BcaN9mEa79EsLkwnjGLQM9AvsFJSUrzeZiTExsZCqVSisbFRtr2xsRGJiYkeb5OUlAS1Wi1bz8KFC9HQ0ACbzTaiSQTPPPMM7HY7fvrTn2LGjBlS/Zc7SqVSsmfQ6XRwOByorKycUAarJLCmCGI6ZySRosbGRuTm5mLatGmydJU/8UWKsKurC0eOHIHBYEBmZua4Uh/+FlhmsxlHjhyRhmF7OzAFK4LldDqRm5sLs9mM5ORkJCYmSgNmBUGA0WiETqdDUlISYmNj0draira2NskgUzyJx8TEBNy7a6xMtnQnMHyRsFarRVJSEpKSkiRB3draKnlvhYWFSe/laLy3ZGtwutCw8wCa3vxuYJtL/lq7+gYGMwvuxxtOYCnUSsk8nWl1shl/4pgcptBDOC6EmBAhXe7fiRdhfBqRh/sxyaLc0oV8pyE/R5B/ffnPuxFyscZFs2Rib/QRrPEKDY1Gg/T0dOzbtw9btmwB0B+h2rdvH2677TaPt1m3bh1ef/11uFwu6bxQUlKCpKSkEY952rt3L7q7uzF//nwAwNNPP43u7m709vaiu7sbZrNZ9tfb2ytdN1GOJSIksKYYQ0WwXC4XiouLUVtbiyVLlnj9FeMPxpsiPHbsGAoLC5GWloa0tLRxh5L92dXY3NyM7OzsEdW0BSOC1dvbiyNHjkCpVCI+Pn5I8ccYg1qtHmSQ2draioaGBpSUlCA8PFwSWyaTiaJbAWQ0XVi891ZqaiocDoeUThS9t4xGoyS4hvLeEnH12VH15B44e6zyK5xc4bpKAYH/jLuX3zi5tJxKGJhOEzYQXesfk3PcxV0ZBcnTSoiULjOowKcLZb5XMisFvrbKOCCwmABxvuCQt5fVZhkAoXngfgUvacwxRLB8Ecm56667sHXrVqxatQqrV6/Gtm3bYDabpajSVVddheTkZDz++OMAgJtvvhnPP/887rjjDvz85z9HaWkpHnvsMdx+++0jfsxTTz1V9v8777xz3M8jVCGBNcUQhYy7N47os+JyuaSBx8FY12jh3eRXrFgh+QSNF39EsPjasMWLF2PatGnD3ibQheTiMOn4+HgsWrQIhYWFo3p895M039FWUFAAh8OBqKgoxMTE+DQFRXhmPG3uKpVqWO8tvlh+0IiXbiuOPvI+zPm10C+R1xYyXmBp1IBjoEBdULqt1TGQSpN5YvFeX/yYHOWAVxWTmYyaAIGbSQgv0SiZ3wN/HIwaMAYFhrBi8FabZYLXTsNhIljur62vRuVceumlaG5uxu9+9zs0NDRg+fLl0oBlAKiurpb9IJoxYwY+/vhj3HnnnTjhhBOQnJyMO+64A/fcc8+IH1M8rorH2KysLKxcuVK63n48XSx2Top/ExESWFMEPkUI9H9pxXB/U1MTcnNzkZiYiAULFgSlg2MsgkasExMEwSdu8jy+7mp0OBzIyclBd3f3qGrDAtnNWFNTg6KiItlsRvHA5ukANxLx597RZjabZSkonU4ni24Fu3tooh7IveFLHyF3762uri60tbWhtrYWhYWFkvdWTEwMdDYBVQ//G33VrR7vi3E/phQapawcatBK7VxLoZLzYeMiq7IxOUretZS/HAFx6DOD2q0Qno9G8T/03KNZovO6AJlA44vXZV8J92hWE3eZ7y4cXYrQl07ut912m9eU4JdffjloW0ZGBv73v/+N+fF4wdbW1obzzz8f1113HU499VQsWbJkTKaloQoJrCmGKKpEb5WSkhLU1NRgyZIlSEpKGubW/mO0Eazm5mbk5OQMsjXwFb4UNj09PThy5AjCwsKQkZEx4loFIDA1WLwR68qVK2XdSb50chcEAQaDAQaDASkpKXA4HDK/JrvdDpPJJItuTTbBE2j8ZdSoUChgMplgMpkGeW8Vf30Iqs+qoKnmu+/knxNmd/O94suReGNQMMDGWzEMfBeYmhMd3JgccMcCxhuLCnyjThQgNHD/9+bizh9X+NtHutVj8QKNLy3ghRFfPxQJadA0U0PmEO+GP1OEoUBERAQefPBBPPLII7j88stx6aWXYtmyZUhMTJzw5QQksKYYYtjVbDajuLgYLpcLmZmZQR8cOlKBxRhDWVkZjh49OuI021jwlcASGwbEsUKjPdH5uwbLZrMhKysLNpvNoxGrP4c9q1QqxMXFIS4uDowxWCwWtLa2oqWlBWVlZdJwYzG6NZYC66lOoJywxUilvsUO5+slUE0zoo8r6O7q7JJJDZnAcrdl4ENAKiXAfQ8F8LcTpMiXfEyOi/O9GnjeTNYpOJSLu5eZhLLarAi3gnk+GsYPfeY2y6JZXKchYiAMjttJTGaBFRsbiw8//BAff/wxPvroI7z//vv4+9//juXLl+O6667Deeedh9jY2AlrA0NHrCmIQqHA4cOHkZiYOGoDTn+uyeVyDTk3zWazITs7G729vVi7di0iIrz/6vPVesYKLwSXLl065oYBf9ZgdXd34/Dhw4iMjMTKlSs9Chj3CJr7Wny1NkEQJP+bmTNnyoYbl5aWwmq1StEtf7mRT9YuwkDVsHQeKEPVkx+B2ZzQquWfJZ0uDDauwNxmsUqxIUGtkOsQLoKl1Mk7gQVwtU5KNpBa5AMdgjdH9yFqowS+069j4CLjzUu9RLOYys1+gZ9D6M3YlItmDZEeBLwLrGD/KPYVqampuPHGG3HjjTdi79692L17Nz755BPcdttt+MUvfoFrrrkGP/vZz4YcQB2qkMCaIognytLSUjidTsyePRtz584N9rIkxAMIP0KBp6OjA1lZWTAajcjMzPR7NGM8Akv04jKbzeMWgv5KETY2NiInJwezZs3C7NmzhzwBB2PYs/twY4vFgra2NrS2tkpu5KLYio6OpuiWFwI16Lnt8wLU/N/HgMtzxEylUMqn33BF7uZeiyz5JrickuAS3Jzb4RoQWAIvXhR8Wo4bBs1Hk7z5VvG+V0wJKDq42/DRLC8zCWEEwPtueYtmcbdnvG+W9w5CYPAx0eVyTZoIFtD/GRWf45lnnokzzzwTjY2N+Ne//oU33ngDr776Kl555RVceuml+Ne//hXs5Y4KOipNEXp7e3H48GE4HA6Eh4eHXCEhX3zPH0wYY6ipqUFxcTHmzJmD1NTUgJwwxiqwuru7ceTIEej1emRkZIx7DImvHeUZYygvL0dlZeWIImtDpSgDWR8VHh6O8PBwTJ8+HU6nU7IPqKioQH5+vmQfEBMTA4PBMOa1TbaaL38LLNFAtPObEklcARhUqc53DQIAbC5pH32EAaxjIEXX09Ul9e4JWrf0oYsXTJwBqWxMzoAoYoJloPhdLvG4y+7RLK7TT1ZnxYk4mUAyyI1NZd2BXqJZsvdk6AiWw+GQHRN7e3vBGJs0AgsY/L2Lj4/Hz3/+c2zevBm/+c1vsGvXLr/MqvU3JLCmCEePHoVer8eiRYvw/fffB2QMzGgQixn5dTmdTuTn56OlpQXp6emjnhQ/3vWMVmA1NDQgNzcXqampmDNnjk9ObL6MYDkcDuTm5qKrq2tUkbVQG/asVCql2qy5c+dK9gGtra2oqqqCUqmUxFYwZu2FEv4UWMzpQu2fP0frf3KgS4uTX+n2mHJbBqUsgqVUq2Se6mFc1Mpq64WBK10SHFzBu0wweRtNw0WTZDMFvXQKIhKymYQyscSPufEyZodFuD2ml2gWHw0bJkXoHsESDX8nS4qQT2FXVlaiuroa3377Lf71r38hPz8fSqUSGo0GCxcuDPJKRw8JrCnCwoULJfGiVCr9ZqI5VgRBkEVrRKdztVqNzMzMgDv4jkZgMcakbswTTjjBpzMbfVXkbrFYpNdzNJ2Mvuwi9Bfu9gGdnZ1obW3F0aNHUVBQgIiICEmQDWWOGQrPxdf4S2A5rXZU/3EPug6U929wT+u71+o5uIHNGhVYL5fqU7ilEwUmyY9wo0EWBHL29UgnLeYcPCaHQQ3huJBicBNIMuEzIHaY15mEkfA+ZseLsSgiITcz9XJ7xo3JGWLQMzA4qt/T0wOVSjWqbuRQpa+vD6WlpcjPz8ehQ4fwwQcfoLi4GIIgICUlBVu2bMEll1yCs846y+MosVCHBNYUwX0eYahFsIAB7ymx82769OmYN29eUFp1RyqwxMJ7q9WKtWvX+jxs74sIVmtrK7KyssZkaTHUyTkU02kKhQJRUVGIiorCnDlz0NfXh9bWVrS2tqKmpkYyxxSjW5PhJDUU/hBYjm4rap79ZEBcYbBIcps9A+aQ2zLwM5oH3ZbbV6lRyQSWkjP0tFs7oDr+URZYByAATGkaKFgXjBBkKb4O7jIvzvjUn7tvFXcbmW+Vl+J12RxCN68r2WXeN8t7BIuvTxIR669C8fs3UkTR+O677+Lmm29GZ2cnVCoVTjjhBFxzzTU488wzcfbZZ0/4KB0JrCnIeMfS+AuFQoHKyko0NTWNq/POV2sZTtiIsw8jIiKQkZHhl0Lr8USwGGOorq5GSUkJFixYgBkzZoz6PoaLUoV61Eer1WLatGmYNm2aZI4pii336FaoP5ex4GuBZWvuRuWDu+GyuUXA3UTSoG5TGxfBUisx1DeLObjBzyrufsO0MguHMJUNcAEOIRxKoV+FWe0qKZ7EhEiI/lYMbqk7mdjyVpvlPuDem7Eofxu++J3zuhr0mFzx/DBjcgB4FFgTGfEz2djYiAULFuCss87CsmXLsGHDBpmoClSThr8ggTVF4D+koZgi7Ovrk8wKMzIygn4AGU5g1dXVIT8/32ezD70x1jScy+VCQUEBmpqasGrVKkRFRfn88UMlRThSeHPM2bNnw2azSUOqs7Oz4XQ64XQ6pSjXRPXe4XG5XD77bFqrWlDxu92wt/RAO0MedRn0GG6fC5edK0h3870aZAFl59KH3K4KHefcrlBKBe+C1gSxi09QDZyceywu6I9XFjAudcegdCte5yNL/A9P7v1nkYDgZVAzfxtZ8TsfzXK7vey+hhdYfNR5Mlg0iJ+XefPm4fbbb8dll10mXSeaYE/kETkiJLCmIKGWImxvb0dWVhYUCgXmz58fdHEFeO/ec7lcKCkpwbFjx7B8+XLExcV5uLVv1zHaFGFfXx+ysrLgdDqRkZExrhFCoogSD3ju101kNBoNkpKSkJSUBMYYDh48CK1WK41+MRgMUirRaDROSFdpX0UAegpqcfSh9+A0Hxc1SrfXwu2/7l2DcoHlvrObSOdmD/LWU4KWO13puOiSeuCyWjcgPLS6SAC1/evvYdAf10vMFQlByXf98WKL89li/OkxAl6L5/k5hLLXmq8b5W7P1HL7h2HG5Ij1qSKTQWCJac99+/bh4MGDWLZsGRYtWiQb5zYZIIE1BVEqlSHR8soYQ1VVFUpLSzFv3jzU1dUFe0kSnoSNu+t5IA5yo63B6urqwuHDh2EymbB06VKfHKz4KBV/eaJFsIZCEATJWT4pKQl2u12KbuXl5cHlckmeWzExMQFvuhgrvhBYnf8rR+1Ln0viCvAgsNzDUE63FGHfEBEsyO0dmM0u6RSBMx1VaLjTFff6MyXfZjhw3yr1QARKb4gG0H98sVrVEP1LGVO6ubjznYLcc2ThXDTKfQ4hVyQm6w7k1itzbjdCnInY36logjf8PYcwWIjHjZKSEnR3d0vH0omeEnSHBNYUwb3I3Ww2D7G3/3E4HMjLy0N7e7uUwmpqagqZyJr4i9HlckGhUKCzsxNHjhyB0Wj06nrur3WMVMTU19cjLy/Pp2nL4R5/sggsQP5c1Go1EhMTkZiYCMYYenp60NraioaGBpSUlCA8PFw2pDpUo1vjPWG17s3BsRf2QR3t9mNCOfR9yiJYSgXA2zS4izPOP0vQqGVBIH72IDSqgeY9vjmBFyAKz15cglItSR9deAyA/jmEdrsB6rAOaT+nqwsDy+M/225zBGVjcvjuQH5qNf88eef2CEA4LrBgggDvP4I8CSyLxTLhI1ji92X9+vV47rnn0NnZKds+WSCBNQUJdpG7OPxYq9UiMzNTqnXxtanmeOCd5evr61FQUIDZs2dj1qxZAf2FNZIoEWMMpaWlqK6uxrJlyxAfH+/TNYSC0WgwEQQBERERiIiIQGpqqmywcUFBARwOB6KiomRDqkOFsQosl8uFpje+Q+POAwAGR52EQSdCt4iVk7dlUMLVywkl965BLkKr0Lqdkhh3nUqQ6tEFfhQPH2gSHJyxqMPLhL8BcaZRR4NxxeeMDUSzrNYehInZR1k0ym0Oobfid2/RLN7YdIxjciZ6BEsUUjfddBM+//xzvPrqq7j99tsxc+ZMShESExuVShW0IncxypKSkoK5c+cOKr73x1iYsSAeAIqKitDY2IgVK1ZIY1sCvY6hXhOHw4Hs7GxpLI8/bCImS5G7rxAHG8fHx4MxBrPZjNbWVjQ1NaG0tBQ6nU4W3QrmCWMsAos5Xah/5Su0fHBE2jYorefeNehyL2qX2zJgCN8rxg9z1qhkHqACZ4cgcAILauVANEvBj8zh0piCZ9d3ecEYH1lSQqUaSPcxNiCWzJZe6CVfXt5YVOOWIuQzA/xj8s+ZtwYZnQcWMHlShIIg4OWXX0ZXVxeeffZZHDp0CKeffjpSU1NhNBqh1+sRHh4OvV4PtVqN+fPnT7iRWBNrtYRPCEYEy+Vyobi4GLW1tV6jLMGOrPHYj3cyiV2N4eHuLduBYSgRYzabcfjwYYSFhflkLI+3x/d0WWQqCiweQRBgMBhgMBiQkpICh8MhRbeKiopgt9ulIdVidCuQkb/RCixXnx1VT+2BOa9Wtt29MH24rkHY5bYMsm+1ewSL+84r1HKBBRdfu8VtV2JAYAmeHd2ZYObKpvjIkreZhBGykTc6HVf/xUXsenocMESK/zNCmmMIuHUH8vVc/GPyvlmjF1iTIYIlfi7/8pe/oKamBsnJyTh8+DC++eYbr7epqKhAampq4BbpA0hgTRGCadNgtVqlrrbMzEyvYiVUBFZHRweOHOn/9b58+fKgiSvAe5F7S0sLsrOzkZyc7FczVl7guZ+sJ2MEa7ziRyyUj4uLA2MMFosFra2taGlpQVlZGbRarSS2TCaT33+Rj0ZgObqtOPrI+zDn10LlVnM1qG7KXV8NimBxwkgtf46DtBlvQqpWyHQJnHyHHl/X5eIa/njXUi+pOz6yxEe2ZKdAA+RDmwfsG3S6gf00moHjgcUsIPy41mFMAUHmtcXXZvHdiSMfk+OtBsvXZQCBRjxe/fWvf0VbWxusVitsNhusViv6+vrQ29uL3t5eWK1WWK1WtLa2IiZmaDEaipDAmkKIJ8RA2jS0trYiOzsbcXFxWLRo0ZDpklCowaqpqUFRURHmzp2LkpKSoNcZuReZ852XixYtQnJysl8fnxdRnmwaJpvA8iWCIECv10Ov12PmzJlwOp1ob29HW1sbSktLYbVapehWdHQ09Hq9zz9vIxVYooGotUr0kxo6JTiIoQSWuy2DO0N5ZHECS8EJLEE26LlfCDEoIUheVyoI6IGkBL2MvJGtmg1hLMrNEdRoBroTtWFREGcX2m3h0GgHRBkTugZ0qKw7kROUwwx6nqwRLJF169YFewl+hQTWFCQQkSLGGCorK1FeXo4FCxZg+vTpwx7og2mAKhpzNjY2YuXKlYiJiUF5eXnQa8L4CJY4/Lq1tRUnnngiTCZTQB5/KnYR+gOlUonY2Fipls9isUhDqisqKqBWqyWxFR0d7ZPo1kgElrW6FUcf+wB9NW3StuGL2t0ex/H/2fvv8Ejy8lwYvit0zkFqqZWzZqRJkkZhlt1llzWLAR/znsN3eDk+pGPz8fozHPyuExzbYB9jMngxwWuDMT4+xnDAmYUNLJsnj6SJyjmHVqtzqvD9UV1Vv6ru1iTNzC7Sc117rabVVfWrUnfX3fdzP/etfZ9obRm02+qvskAyWHowxpHtP2KfhF8VJUYkHMU4ASqcf9CjtPtEGKHNESTZLGLdlD4mh3RhL27FwNCqhstg8EI2LRVFCqRvliDEoF5CgkG7BQbr50GDtVdqH2DtwZKBzJ3yHMnlcrh8+TKi0Sh6e3tvOKTzXrUI0+k0hoaGIIoiTpw4oUyB3YrJ526XzGDJawSAgYGBu+bDtC9yv3NltVphtVpRXV0Nnuexvb2Nra0tTE9P4+rVq3C5XIpY/laz52ST2FKVuLaEmT/+lwKGimJ1x7oOg6WxZaAprfXC9YKgs6Rzu+44OcJ0VNNmk0CKAFZlrWgHgDDxs9zucwPUOrFTUidFADjNpJ8u5qaUsShxC6WI6UAKbhXsARCwrUjrc1wUBgXL3bwGK5lM/lwALFEU8Y1vfAMOh0PRMcqidlngbjabYTabYTKZ7ojG9E7XPsDaQ0W2CAEUhIjuRsViMQwNDcFqteLEiRM3FaZ7L1qE4XAYQ0NDRVuYrwWARVEUeJ7HqVOn4PP50NHRcden0va6TcPdKIZhFG1WS0sLUqmUwm7Nzc2BYRhNSPWN3mx2+hIVOT2Fuc/9CGKWB+vT3rD1oKhw8k8HkjjSloGFkN4BNBUALIKZ0hxHBLJqa40SSbAlMUo5ygZjHvyIDNHiowgrBMoBuY0nwqizUiAnDUsYiwLQuriTDBT5HL3XVR5giQawLKn7UsHa/FwCNssmPB5P0fe1IAgFTObPg5M7IDFxH/nIR0r+XrZHkV/7ExMTd3F1u1P7AGsPlvyGLfbt6HZqaWkJ165dQ0NDA5qamm76Bnw3bRpEUcTCwgLGxsbQ1taGmpqagvW+FjRhm5ubyOVyaGtrQ319/V0HNXvJaPS1VBaLBVVVVaiqqoIgCIhEIgiFQpidnS0IqXY4HCVfF6UAVujZK1j882cVpqlgSlAPivS70IMkorVPGVmAAFjQM2gkOKMAMcerwnfyqQZWexyesGDgJXaJJ1p0oElHdwKAkmALTh3AIm0VyM8eEizp24Ulcgg1t1NSz0U4twMwGNRjcjknxhfGkclk4Ha7lfawzFhyHFeQifnz0iI0GAz44he/CI7jEI/HEYvFkEgkEIvFsLKygunpaWxsbKCsrAyBQOBeL/eWah9g7cGSQzQ5jrsphqlUCYKAkZERrK6u3lY+391qEfI8j2vXrmFjY2PHIOSbcVHf7RJFEWNjY1hYWABN02hoaLgn65DXUqx+HluEr0VWjqZpeDweeDweNDc3I5PJIBQKIRQKYWFhQQmnltkt8j2tB1iiKGLtH05j89+GdmzjFWqursNgEb5XtFFry6C/pqTvFW00aFp/5FMZi5alozgZGIkAJwEegSYDoNXbmUhE5oia25ye+SGBE9n6I4+tbxcSbJambUnulwyKJpzbdaHPjY09aGo0KXq8ra0tzM7OgmEYeDweJJPJginm3RK5f/3rX8cXvvAFrK6u4siRI/jqV7+K3t7e6273ve99D+9+97vxy7/8y/iXf/mXWz6+2WzGY489VvL3q6ur+I3f+A0IgoB//ud/vuXj3MvaB1h7qOQPOoqidg3MpFIpDA8PF+iXbqXuBmOUSqUwNDQEiqJw4sSJHbVM96pFmMvlcPHiRaRSKRw7dgyDg4N3fQ1y7WTL8FoEI7dTrxewaDKZEAwGEQwGIQgCotGoArb07JYcFgxIOqmlv/gZQj+5VGjDcJOaq8KpQVKorp9A1P6T1GtRRkbbpSOyBym9qzsnMUei0QoKkiBfpAkgpDkOKV4vbSwKmtBWaewbdsohJNuFJJtFflaUcG6HU91edIDKAzFSjyczlltbW9jc3MTMzAw2Njbw4osv4sCBA4jH47fdIvz+97+Pxx57DE888QT6+vrw+OOP49FHH8XY2NiOFhCzs7P47d/+bdx///23dXy5Sn3ei6KIiooKfOlLX8L999+PL37xi/jt3/7tXTnm3ayfr+Cf/brh2g03942NDZw8eRJOpxP9/f23HRFyp1uEoVAIp06dgtPpRF9f33WF4veiRRiPx3Hq1ClQFIX+/n5YrdZ7euOXQZUoilhdXcXS0hKSyaTmd/t174qmabjdbjQ1NeH48eN4wxvegOrqaqRSKVy8eBFzc3OIRCJYml3A9Kf+FaGfXAJQrCV4PVuG0lE4gE5HZdDLDnQMFkeyXfpoHDLcmcwYpEHJlg1k0DPBtIlku44mMwHJtZKMvUO3NGJSUPO6Jj8nXNptKKLFKJKCeXK/5HQiAYzE0sy5x+NBU1MT7HY7WltbUVtbi6tXr+IjH/kINjc38Vu/9Vv48z//c4yOjt7Se/DLX/4yPvjBD+IDH/gADh48iCeeeAJWqxXf/va3S27D8zx+5Vd+BX/8x3+MxsbGmz5mqZI7KjRNa/4DJODZ3t6Op59+eteOdzdrn8Hao3U7DJYoipiamsLMzMyuejHdqRYh6R3V3t6OmpqaG9rubjNYGxsbuHjxImpra5UYIZ7nFYBzLxgj2SbiypUr2NjYgNVqxczMDMxms9KK2m0t337dehmNRlRWVqKyshKiKGJ0dBSx9TDWv/Ic6HHVhkHUS6x0mqtCp3bdP/W2DFmCwdKbkuqL2LYAjJHZg0ZGzR60EC03s/ozxZB6LpWBEpHSZBKqRR7PDnnqUCqyDUh+DhEsmWjXeWqROYQkFVfCuZ1sHV5nghCQ3ltmsxl+vx/f+c53wHEcvF4vHnjgAfzoRz/C7/7u76K6uhqjo6M3bOuRzWZx4cIFfPzjH1ceo2kajzzyCE6dOlVyu//5P/8nysvL8au/+qt4+eWXb+hY16tSnxvy6y8Wi2FxcfGO+/3dqdoHWHu0btVzKpvN4tKlS0gmk+jr64PT6bz+Rjexpt0GWDzP48qVK9ja2rpp76i7JbonPcM6OztRWVmp/E5p79wjgMVxHDKZDGKxGI4dOwaj0QiaphEOhzE3N4dYLIaXX35Z0QD5fL67ZiFxJ+rnqe1JURTYBA/z/7oCltMqjDJcTnPbL+BACgb/9AyW1ruKBFx6gKXfVuvyzmiOTUFQ/k0RAIs2qyCHMhI/M2QrsJTXFSlqJ09Mz7gXNxbVNnrIHEKzzkCUAGilnNvJW+51YnIA6fOLtNlIp6Xj/dZv/RbcbjdSqRQuXbp0U55pm5ub4Hm+QDgeCAQwOjpadJtXXnkFf/3Xf43h4eEbPs71amFhAa+88orymWGxWBRbBrPZjEwmg6985SsYGxvDf/pP/2nXjns3ax9g7aEibx634uYeiUQwNDQEp9N5R7Lvdrsll0wmMTQ0BJZlceLEiYJpnBtZz50GWDIADIfDRT3D5L+ZIAh3LA6nVMXjcVy7dg0A0NfXh0wmA0EQQFEU/H4/0uk0WJZFU1MTQqEQ1tbWMD4+DqvVqoAtl8t119e9X1Kl50NI/dnLELdToCq0ryubw450SAUHsUQcO76bd7BloEwGiBwBSPRsmG5Xok6vpdmzQLQPyf2Y1NWJRPQOTZOwkdRTbROPFzcJ1eqxbABD+mPdYLtQk+tDarPI+B7iM01DHe5sMgoUssOJhAQcZQ2WxWJBX1/fdfdzOxWLxfCe97wH3/zmN3cl8F4+p6eeegof+tCHlMdZloXBYIDJZALP84jFpL/no48+ig9+8IO3fdx7UfsAa4/WzbBFoihicXERo6OjaGpqQkNDwx35pi8zRrvB1shZfZWVlWhvb7+lm/ydBliy4J6maQwMDBQFgPK677bWSW5XBgIBbGxsKK3KXE7A4186g0CFDR2dRrAGEVarVQk7zuVyCIfD2NzcxNWrV8HzPLxeL/x+P7xe702D3P26tYqPLmP2k/8MMS4BHz2rpP+30+1CakVlgLa3IxrAJereB5qpQQOjMTi4KQZL79zOk79TPwNoQvBOMZQSCE3TZFtOYqBEWEBp2nUkm0U6w5McHiE+L9iGBEgkA2UjxO8GneCdtH8gjknG/dwgg0UCrHg8DqPReFtfbv1+PxiGwdramubxtbU1VFRUFDx/amoKs7Oz+KVf+iXlMflzkWVZjI2Noamp6YaPL3+2d3V14cMf/jAYhsH29jai0SgikQji8TgEQYDb7cZb3vIWvOc977nlyfR7XfsAa4/WjbYISUsDOULmTq7pdvVGZLvtdvVhdxJgyQan5eXlOHjwYEkAKD9+N/3BZL1aR0cHLBYL1tfXwXEcYjEOH/q1p3HylSXUNzgRjabgchnxi29N4I0P16DneAUMBhbl5eUoLy+HKIqIxWIIhUJYWlrCyMiIZsLN6XS+plpyPy+C/cjpKaz87Svg4wTI0AMZnYhd//pzOOxIE5qkeCyubSmSLJReR6X/m+oF8ZlSxqLQAixit5SBVpNyGJEAWBKQEWmHGrRMuyAbi0pVwrm9VOsPQMl2IVWqxaj1utJuXxj6LHA+LJ3pQ10PSpYoikUZrNu1aDAajeju7sZzzz2Hd7zjHdJ6BAHPPfccPvzhDxc8v729HZcvX9Y89gd/8AeIxWL4yle+csOaVrnk11p3dze6u7tv7SReJ7UPsPZQ3WyLUG6xMQxzXUuD3Sj5g0SvO7jR4jgOV65cwfb29k1F9JSqOwWwFhcXMTIyokwH7QQySA3WnS45j3FjYwPHjx+H0+lELBaDKIr4xx8+jy99bgFLSykcOuzDxHgY6bSArVAO3/jaML7xtWG4XCY88MZqvOUX63Hivir4/BKz5XQ60dDQgGw2q7iTX7x4UePf5PP5XpdRGK+1Cj19GYtf+ylMQbfmcT2QKfC50r0EGUoLmkysQSMV59JZZZOCiUS97xVPvHZpCiKnGosWsF2kYSnxK4pVARZFq59bDJ3P/mOckFuEImWH6txe2iRU1PBupG+VRdviK9liJMXvpNeVSdciJFuXSQi5cnz7P3wQJ35N1VoWK/mzhwRYyWRyV1zcH3vsMbzvfe9DT08Pent78fjjjyORSOADH/gAAOC9730vqqqq8JnPfAZmsxmdnZ2a7WUtq/7x65UgCJibm4MgCAgGgzAajYr8QRRFTExM4NKlS4hGo2hra0N3d/fr2rV+H2Dt0boeg7W+vo5Lly6hqqoKbW1td0VHIx+D5/mbvtkmEgkMDQ3BaDTedETPTuvZTYAlCAJGR0exsrJyw2wgqcG6k5XNZjE8PIxcLof+/n4YjUZks1kYjUZQqMc//uA8UikeBzvsuHI5pDfyBgBEIhlMToTx+y8uIhrN4vCRMjz0cA0eelMNjhwNgGVZVFRUoKKiQuPfND8/j5GRETidTgVs3Wr23l4tURSx/r0zWP3fJwFcvyVYaMOgA0U62TsDWgOwqJz6ekznslq/H71AnvgiR5tYgJg4LBBocaTpKNFOI+9UlLQSHgbQtMROiTRxE6YIsEQ5oDUTJcEO2frTG4uWAEiaHEIShOrZLJJBU9msXNqKb/3Sf8HsKza85fd3/sIqfwHWtwh3w2T0Xe96FzY2NvCJT3xCMYh+6qmnFOH7/Pz8rn7my12JkZER/Pf//t/x5je/Gb/7u7+rsWh45pln8Ou//uuYmZlRtnvb296Gv/iLv0B1dfWureVu1j7A2qPFsiwymUzB4/K3iLm5uYKJtjtdNE0rtgA3U7JeqLq6Gq2trbv2wUDTNHK53PWfeAMlA5hsNouBgYECd+brreNOMljxeByDg4NwOBzo6uoCIJmdiqKI7/7vUfzBx18CIKLzkBdrqzEc6/IhEslieiqmAVrHuvy4emUL2az09xseWsfw0Dr+7EsXUFZuwX/8jy04fLQMDz5UC5fLDLfbrXg4ke7kcvaez+eD3++Hx+O5qSmp26nXI6gTeQGrf38S698/qz6ofw/QepapYC/afxaI2gkwwtCatp/RYgZHAJJ4PK7BTVpjURZiloi80QM9jsgbJE1HSTYr37LjKCuMcvuPIUEVCZb07zMCLGlafwRYIrVVAEpaMWjek6TXlR1KuLToUAAan6nGXz76f2HhrLQmR2BnPaIMsMjPs93MIfzwhz9ctCUIAC+88MKO237nO9+5pWO++OKLeP755/He975XsaFhGAaLi4v4/d//fczMzODhhx9GVVUVrl27hieffBJf+9rX8OlPf/p1OSyzD7D2UJE3j2IMVjabxcWLF5FOpzEwMHBP8q5uVnw/PT2N6elpdHR0IBgM7upadovBisViGBwchNPpRFdX102DhVsBnTdam5ubGB4eRm1tLZqamsDzPHiehyCI+J+fPIVvf+sSXC4TysqNGB4KAQBWVqT/uz0mNDd7wHE50IyAwfObJY8TrHLg7/5uBMknLsFgoNHVHcBDb6rBmx6pQ1u71B4k3cm3t7cRCoUwNTWFVCoFt9utsFtWq/V1CYTuRAlZDvOf/zEyaxHN4wUMlh7IXOf6FYjaNeagDISU+nuDSds+NBi0/84k1Uk72qCN0Sk4blZtPUIkdF40AdIECcxxlEmBNdqYHBKNqSBGhAOgyetETACWmhQUrTr7h1LO7SSbRTJTUuuSS9fir978a1g4q4I/e/nOLLsMPsjX+m7F5Nztkhms4eFhtLe3K5E8giCAYRh8//vfx4ULF/Arv/Ir+OY3vwmz2YxYLIZf+IVfwA9+8AO8//3vR3t7+z0+i5uvfYC1R0uvwdre3sbw8DDcbjeOHTt21xgDfd0owOI4DpcuXUIsFtt1Py65dgNgra2t4dKlS6ivr0dzc/MtAYM7xWDNzc1hfHwcBw8eRGVlJXK5HARBQCLB4bN/ehr//m+TqKl1IJPJYnIiVrD9djiDK1c2cPCgH8OD6zhw0AeH04DVlTjm59S2zJGjbly+uAEhz4rkcgLOnF7BmdMr+OyfnsUb7q9CQ6MLDz5Ujfvvr4HVZlRCb1taWpBKpRR2a3p6GkajUWG33G73njU55eNpzPzJvyJxZQmWZl28SUGU4M7hzQUvL17HYBEtQcrAAqnSYc5Go0kDsEi2Kytw0P61iOMwNCiBnLIjABYJy4R80DNFABQSQBI/ippZSDu04nOyXUiumAQ+TmhBFSmYJ9ks4mGdczuXbsBX+t+HbMIBGdRZ3CwM5p1ft8UMfHeTwboXNTExgWAwqOS/yp+Hr776KgCJVTObzUgmk3A4HHjLW96Cz33uc9je3r5XS76t2gdYe7RkICOKIubn5zE+Po6WlhbU1dXdU3bgRryw4vE4hoaGYDabMTAwsCt6q1JruVWARbrdHzp0qOj4843WbkfSyFqw1dVV9PT0wOVyIZvNSnYcC3G8/z0/xvjYFjo7fYgnkggETHA6LZic2Nbsp6zMArfHjMEL0rj3yLWQ+rtyKxobXTCZgbOn1xRwpa/ungDOnV3FKy8v4e/+9hpMZgb9/ZV46E21eNMjtaird8NkMqG6uhrV1dXgeR7hcBihUAhjY2PIZrPweDwKu3U7cU2vpynC7GYMM5/4J6Tn8tf8OiL2AgbrOghLz2AJO0wNFuxb97dmRBUesSYjRAKwJBMJ5SZEm3S6S4EQvCuQTQTFScBIIAOdKYFwbufVs9OI9fXtQtKWoYR9g8aKQZdDiBJeV8T26YgXX73/LdicMKGiwwAZYDnKr29XUgpgvR4ZLLkikQgCgYByXjRNI5PJ4OrVq2hublYkKbKdS0NDQ1Epy+ul9gHWHip9izCXy+HSpUvY2tpCT0+P8q3iXtb13NPX1tZw+fJl1NTUoLW19Y6CwVsFWBzH4fLly4hGo+jv74fD4bgn6yhWuVwOw8PDyGQyCjiVwdWFc+v41Q/8GFuhNHqOl2NocB0S1pVuJH6/BY1NbnCcgHSaw+ZGChPj4aLHSadySKU4nDm9AaORxqHDZTBbaCzMR7G6Iu2vo9OBwQtrmnt7Js3jxRcW8eILi/jeP4yCZWj0DVTi4TfVoK8/CJPJAL/fD7/fD1EUkUwmEQqFsLGxgYmJCVgsFgVsud3u16Vu43oVnYxg9onTEOdUQFs4FbgzY1VQ14nCIb2raL0tgx5g6cEaIWo3mI1aowRinRylWwRh2SDn/IlGCyhRivwRyHMkABKl8awn96mbFGTI1h/ZLiQXoROvkwamGuf2whzCbKwdP/jQ/43NCen1brSq1+16+iugOMDaLZH7vSqfz4fx8XHlixBN0zh9+jTW19fxH/7DfyhgtuSJ8tfrOe8DrD1aHMchHo/DYDDcksv5napSLUJRFDE5OYnZ2dnbZoRutG7FWV62tjAYDLvGru0Wg5VIJHDhwgXYbDb09/eDoihFzP7jH03j47/3EiLbaXR1+3H+3HrB9pubKWxupnCsK4ClxThqahxoanZjeSmOuTn1m31l0A6TicGlixsAgGxWwOVLG8rv6+udaGp2YWkpBoahwHGF53a8txIXh9eQzQq4cnkTf/1Xl2G3G3DfG6rwxocl7VZFpR0WiwW1tbWora0Fx3GKDcS1a9cUk1MZcL1WXuO3W1e+cBEmMaP98Kb0DNZNfvHQa6503lXk5N91bRl0DJZA+l6xWsBgNpoUwMWYDBpwk0sllAYfJeSfZSZYKEKXRdoiiFSaYLDI89BPCpaK1iHf86SxqD6HkPhZY8vAIR3pwJeOvgv+BjPkLyiMQb1Otwqwksnk6xJsyF90BgYG8MILL+C73/0u/tt/+2/gOA5/+7d/i0gkgre97W0FX0bHxsaUQZfXY+0DrD1WFEVhZWUFIyMjoGkaPT09r6lv+cVAjcy0JRKJXWGEbmYtN8McbW1tYWho6Lbc44vVbojcQ6EQhoeHUV1djebmZgiCkAdXwOc+cxbf+Oog3B4TjnX5kEwmUVVtw9JiomA/AyeCOHN6BYIgIhJRqfuqKjtqal2gaWBqKozZmXjBtgDgdBphsxvx3E8XAABWK4vOQz4wjIjZmQhCoQzaD1hx7uxKwbbxeA5PPzWLhfkoPvunZ1FVbcdDb6rBQw/Xoud4JRiG1picxuNxhEIhrKysYGxsDDabTdFulTI5fT2I5/kMD1rXCb3pdRe0BEtPDV4va7DQloF4rdKURoOlB35kK9JgNWlwDk20CLOpKMwABCImB4QflsZKgdiJeMPGotvEokq5vZM5hDrxO8FmxVYr8Hj/fYivGeCtI55C3T7ASiQSuz7MczfrQx/6EJ544gk89thjeP7558HzPH74wx+isbERjz76qPI8+Vo9/fTTaGhouG1Pw3tV+wBrD5WsvVlYWEBLSwsmJydfU+AKKGwRxmIxDA0NwWaz3ZH8w53qZgDW/Pw8xsbG0N7eftPOxjeyjtthsOS1HThwAMFgEBzHged5pFM8PvIbP8XTP5lBMGgHKB4XzqttJwk0OZFM5jA5sYVDhwM4dXK56DGWluKoDNpx+fIGGJrCsa4ATCYGM9PbWFuTbkRV1XYwDI2rV9Rpw2SSw/CQpOEyGmnc/2ANslkOzc0spqaiBeLrnt4KXBpeRzYrIBLJ4NrVEL7+58PweEy4/4FqPPrWetx3XzV8fitsNhscDgfq6+uRy+UUofylS5cgiqLCbHm93jum47sTJeQE0Hqdc4HE6iY1V3pRO6cVtYukfYIeYOmLAFS0kYWQJlp2+m1JUbuO3WKIXEJ5LjHJ55QZPYomgRBppUCK10n9DnmOBEIVjQBNMlA3kkOoZ8Ck4yc3j+Gvf/kRxNek9XIZ9fxIHeKNACx5wo6s17sGq6qqCn/zN3+Dz3/+8/jhD38Is9mMBx98EJ/85Cc1IIqiKJw5cwYjIyP45Cc/eVO2Nq+l2gdYe6jkVtPAwAAoisLY2Niu5P7tZpEtwtXVVVy+fPm2JvBudy3XA1iCIGBkZARra2vo7u6G13v9ANebrVvVYAmCgLGxMSwvL6O7uxtut1vRW62tJvDB//Y0hofW0dbuxfJyFLGo1rZjaSmOpaU4XC4TWtt8yGZ59A0EMTMVxvp6SvPcgfuqcPrkknI/GhpUc84am9yob3BhO5xWwJS+XC4TqqodePnFBfUxtwktLR5wHIepqW3U1ppx/uxq0e3D4QwmJrbx4u++glgsi2Nd5XjjwzV4+E21OHS4HAzDKCanoigqJqcLCwtKhE82m0UymXzNvSf0JWR5UJTOCvR6vla6f+sBuyhoWWOBbAkaGa2Z+XUAliZGx8gAadI8VP/cUrmEIqD4ZYmg+bw43ONWl8FIAIsTTUr2oAgjKKSgXBCNxQJ5jrp2oabFd7M5hBKbFV87ji8c+mXQRIZiNq6eH5dW97VXRe6AZB563333IRQKged5BAKBogzVxsYGfvM3fxPvfve7X3NEwI3WPsDaQ0VRFA4ePAhBEJQbbbFvSfeyZH+usbExLCws4PDhw4q78N2u6wGbTCaD4eFh8DyPgYGB25pg26luRYOVy+U0nmYmk0n5m1++FMIH3vsk4rEs3vhwFdbWtsEyxQFFTY3Ujh0e0mqymprdCJTbEN5OweEw4dSrSyXX4vNZ8OrLi8hkeAk0tXpAgcL42BYikQyqa+ygKBrXrmp9tCLbGZw/twqDgcKxrgpEIhn09VdgdTWOuVltC/LoMT+uXQsjm5FuYhfOr+HC+TV86fPnEQhY8UvvaEJ3dwAPvLEGTqcZLpcLLpcLjY2NisnpxMQEpqenMT8/r2G37pVlSakSsgIoWg+ZrsdY6XeieyCn02BxWlE7CU30gnr9S1MgGSwDq/W9KojRKd56pIysumijAZSYfx4RmWNgJVAk0k5QyOv9ciawVvKLAslmlXJh19OBJbILS+YQOhFbOYzPd7wduSQDkRDZpyJEmzNJAKzbaBG+nm0a5JJNhneqt7/97Xj7299+dxZ0h+q19cmxX3etyNy/1xLAAoClpSXQNI3+/v57+m1tJ4AVjUYxODgIt9uNQ4cO3dFreLMarGQyiQsXLsBisRSI2Z/89xn8v//9p0inefQcL8MLP1vKHwNobvagLGBFaDOF8bEtdHT6sbgYQ2S7cEx6anIboVAKwaAd4+NbON5bCVEUMT62hWhUvSkN3FelAV+R7YzCQjEMhQffWANBBJYXC322AEmzVVPrxNkzWk1WWbkVDQ0upNJZMDSPi8ObReN7AMDlNuOffjCBb/3lZRgMNI73Vkjs1iN1aG31KianCwsLaGxsBMuyCIVCmJmZwdWrV+FyuRTAZbPZ7jm7JWQFQD9xV1DXYax0LUFhp0Bm9jpTg3r91k6WDvpLRzJYxFNpi8owUWYCjDA8AbAkpokxOiHkARZjcEHWYAkiDY0eS0wRVg7EmkVdu5AiJgpvIIcwsnAQXzj8MHIpBlavAcktFWAlQup7J7WtnuvtAKzXO4O1l2ofYO3RkilXjuNeM/qTaDSK9fV1GI1GDAwM3HPmoBTAWllZwZUrV9DY2IjGxsY7fsO9GQ2WLLQPBoNobW2FIAjgOA6iKOIrfzaIL33+LMwWBh2HPDh/Tp3sE0VgcjKMyUnJduH+B6uRyfBoavZgfDSEeFwbGVRX5wTPi7h2VdJsyaJ0hqFwsMMPt9sEo5HGC88voFQd6w7g9KllZPKsUyBgRX2DG9ksh9HRLXjcZhgMWs2WXBvrSWyFUug5XomhwVV0dPphtTJYmI9iZUW9KR446MLMTATplHSMXE7AyVeXcfLVZXz6T87gyLEydHcH8Ib7q2CxSc/xeDzweDxobm7WmJzOzMzAYJBsInw+Hzwezz35ciK3CLWlB1T6X+/scwUyCoemNKCpAGAV9PluHGDpS9MiJIAbbVTf+7TZSDxH2rdIm8EwKeVn5bmsXbkSFOWESEz9ZbJbMOexlCBwoJWl6Y1Fidcb2S7U5BBKn5/h2Qfw/ff/R+RS0hcEq0cFWBYXq2Gw4psq2HJW3BjA0n8Gvt5tGvZa7QOsPVYyGKAoqsDN/V7W8vIyrl69CqfTCZvNds/BFVAIsOScxvn5eRw5cgTl5eU7bL17daMM1uLiIkZGRtDe3o6qqipFzJ7NCnjso8/j9Mkl3P9gNVKpJC4NF/evoiigf6AKL7+4qDxmMNDoPOSHw2HC0mIMTpcJ83MRDVMlF8+LWF6KAZDAV2WlDXX1LqRSHEZHNpHJi35P3FeFU4RmCwDW1pKKIL6j0w+TiYHRxIDjBSwtaluCNhuLpmYvzpyWRPdXLqs3xeoaB6qq7WAZEefOrSGbKQ5OGxpdWFlO4NtDV/Dtb12B0Uihr38Vv/BoIx5+pBa1ta4Ck1M5wmdiYgKZTKYgwuduFJ8VQBUYV+meVNC30zNYOp8rMgrHwELIELopXfuY0slhCkxJs+S2+naiWPq5pK2ViVXOiTKRnwXS8wXWARrSa5iMydGAJcoBcjrQZFJfr/FEGE53fo+cAGU4UbQDFAno1e31OYShyYfwpaNvQk2PenyjXf3Z4jUoAMviMSAVltZOMxSs3ut/qf15smnYq3Xv72L7dc/qZnL/7lQJgoDx8XEsLi7i6NGjiEQiSCaT19/wLhQJsORonng8ftdbl9djsERRxNjYGJaWltDV1QWPx6PorTY30/jV9/0EQ4NraGp24/KlNWyHczAaGRw56oPZwmJ+LoqV5TgsVhYHDvhw6qRWT5XLCQqA6esPYmUljoMdfiQSOYyObCKXU9dWU+OAKEJhtlZWElhZkVgAs5lFV3cZfH4rLl1cL9nS6+oO4NrVENJp9dt/bZ0TVVV2xGI5bG0lYTYbcOlioVcXACwtxlBT48SrryzBamXR0eUDzYiYnZZsIACgsdGKtbUEEglCI5MV8fJLK3j5pRV86fPncPhoGdrbfXj4TTU43lcJk8mggClRFBV2a3NzE5OTk3fN5FTIFQKsgteH/p+6liD0LUG9MD1TGiQV6Lv0E4hke1G/rX5dWY7wrFJ/SRsZJYmGZMEoUWrfiQzR1tM4upO3NPU5IlhQhJDd4VABTjKZgitPgmWzDIwyISZatOJ3Ympw5UoT/nzgKASe1jBvZPyNmQBbVgJg2cuNoG/Ap+znWYO1V2ofYO3hKhb4fDcrm81ieHgY2WwWAwMDsNlsiMfjdyzY+GZLBliJRAJDQ0MwmUzo7++/6y3VnRgsjuNw8eJFJJNJ9Pf3w2KxKOBqdCSMD7znSSwtxXH0aBlGRkIKg5TN8rg4rAKUI0fL4fGYsL6eBE0X+E4qzJYMvubzxqI2mwGHDnvBsjQ4TsDU5LbGH4sso5FGJsPj2adnAEgMUkWFHZFIGqMjIQgCMHCiCqdPLRWAr/m5KObnomhqcsNoYOF2m9DbXylpwTbVm6DZzOBgh19ZZzLJFUw0NjQ4sLgYKwnkg0E7WJbGyy8u4eUXl/DNv7wEh8OANzxQjTc+JGm3AgEbzGYzampqUFNTA47jlAifkZERcBynifAxm81Fj3UrRU74KaUHLnrjUD3LVODUvkNb73pTgyRYY2it71UBwNLaMlBE240EjZSBVgAWbWBk4gqUkNdXMSZVpk4TJ6+hwcj3qQugNoinqa0/l1MFLLkcpQCsXM4Cg5GcLpRe8+sjb8b/+f8+AIHPs6oEO0hOEBos6nU0EWDrRvRXwM+nk/teq32AtYfrXrYII5EIhoaG4Ha70dXVpbQEXwusmlwyA3Hq1ClUVVWhra3tnowLl2KwkskkBgcHFeAn53pRFIVnn5nHl79wFrX1LtQ32PHqK8XtDQCgucWD5eW4ArhcLhNa2tRJv0yWw8GD/gJmCwASiRwGL6yht68SV69sorbOiYOdfoQ2Uhgf31KeF6yyw8Bq9VQz0xHMTEv+QR6PCV09FYhGMnC5TNguIqw/fLQcU5NhJOI5zM5K21EU0NLqgd9vRSyWAc8JSjZisaqosCkmp3Y7i2CVERaLBdPTEcSiHIJVRiTiaUQi2i8esVgOP3lyBs8/N49/+PtRcJyAhx6uwUMP16CrRzI5LSsrQ1lZGURRRCKRwObmJlZXVzE+Pg6r1apot5xO5229joSsAEq8TlqzviW4k+YK0Dm164TpBQCrdLuRNrIQUkTrWNdeJA1NKRMLTaoNVRyowAAVYOVBjUiTrJVAcGpES19ze7MB2CD+XTzo2WZTQ+MFwQpAeg2L+RzCleFfwJ/3Pwhvg3q9uFzxLz+0Qb1uBrP6841YNACFAIvneaTT6X2A9TqqfYC1x0qfR3gvGKylpSVcu3YNTU1NaGho0KzpVuJp7kSJoojFRUmH1Nraitra2nu2lmI2DeFwGIODg6isrERraytEUUQuJ92FnvjGRXz6T07CYKBx4KAbF4e34PWa0NIqeVmNjYaQTEp/967uAEauhZBKqa+DSESd9AtUWNF+wAeaBhoaJMG4vgZOqMzWxHhYySf0+S0S42RkMDMT0cTpkGW1sqitd+G5Z+cAADRN4cBBH9weM9ZXE5ia2kZffyUunF8Dp2NeRFE6ZiqVA0Ahmciht68SvCBifDSEWEy6JgxDoed4JU4SE43xOIfxMQ5AEjRN4eGHa5HOcFheiiISKXSid3tMqAjYFMuKK5c38dWvDMHrNeOBN1bjoYdr8MaHa+H1WmG1WlFfX6+YnMoRPpcvX4YoipoIn5thREVekNp91xGt653ZoYsjEnZyar+eqF2HJzSu7zrPrIIBEB0YIwEWJQiqQJ0lPxPyx6EoAmARoI+wXxApMuiZBIbkpCAD0KTXFZlDqB7XZCTBlgMzp4/hmw8/BIBCPKRuk00SZqIE2CLP/GZjcoBCgJVISGvebxG+fmofYO3hutsMluwkv7KygmPHjsHv9xc857XAYAmCgKtXr2JjQ/rGezdyD3cqvdheBqhtbW2orq5WxOwcJ+Jjv/Mi/s/3RuHxmuHxsLg4LH0D39rKKIJwk4nB4SPlCASsuKYDV2Q1NbsRj2WV7QAoovVkisPMVBit7YWaLblCmyk0NLhw7twKBF5E56EyOBwGLC7EsLAgMQjl5RY4nCZcJHy2BEHEyDXVUf6BN9Ygk+HRebgMoyObykSgXO0HvFhbTSIclm56sqUDy9Lo6PTD7TGBpmmNiam+jvdW4KWXFhUAV1ZmRUOjC+lUFhMTYVitDChawOjoVsG2W1tp/Os/T2J5KY7HPvoCjnWV46E31eKhh2vReagMDMMgEAggEAhAFEXEYjGEQiEsLS1hdHQUdrtdifBxOBw7TqUqN/DrMFaF2YLaa7ajUzurO34BWVY6zFnvmbWj75W+FUm2D0lsxOSPZ7FBmfAjMwYJnRRFkYMX5Dp1k4IU+XckwRZ53dRtNq6+Ed98uB8ABYoGMhF137FNdfscYSbKc8WZrX2AtXdqH2Dt4bqbYEY25eQ4DgMDAyUnrm7EPf1OVjqdxtDQEAApmPTFF1+855owmcESRRHj4+NYWFjAsWPH4PV6kcvlIAgCtsMZ/OHvv4Ll5TgOHPRiYz2O6anieYCCIMBsZvDsM7MAgPp6FyqDWi3U0a4AxgmmSy5ZtO71mVFX7wbPCegfCGoiceTSu7tfuay2aKprHGhp8SKVyuHC+cLcQUDSbB0+Uo6XXlCBkcnM4MjRcljy4vyKShuuXt1EJl34OuY4AaurCWSzPCbGw6iotMLjocDzNOZmE4oeTe/VBQAbG0lsbEjn037AB4uFhcEAGA0xLC9rz9NopNHRWYazZyTW7/y5NZw/t4YvfPYcKipsePCharzlF+vRN1AFh8MEp9MJp9OJhoYGZLNZxQZieHgYFEVpTE710VB8VpD/iJrHd4q6kf6tA1hZQohu0LFOOt1PAeDTTwJypduLhQBLC8bIPZFu8hShq6LyoIcidWw08bok3NpFKkUwWORrl1yXHXLrTyqiXaixYpC2Wbrwdvzw/3mz8jyr14jEpgrksjF1rdsb6ntOC7bU5zhvEWDF43GYzebXxIT1ft1Y7f+l9liRH5Ysy96VFuH29jaGhobg9XrR2dm5o3fQvWSwIpEIBgcH4fP50NHRAYZhQFHUPWfUaJoGx3EYGhpSphitVqsCrqYmI3j/e57E3GwUhw77MTe7DX+ZGQOtfqyvJzE1ua3sy+02IVjl0Bh3zs5GFE2Ty2VCb18lIpEMDAYGiqsjUXX1LuRyvAYwAaq7+9ZWCk73zu7uXp8FZ88uIxHPwWbPC+UNtCJal6Jz7Dh/Tqsdy6RVcf7AiSBWVhLo6qpANJrB6EgIPAE06uqcyOYEpWW5upLEav60zWYWx7r98PttuHyp+DQiIIn/J8a3NECzulqygYjG0lhZjsHhYDVCerJWVxOYnY3iv73vaRgMNHr7KyWh/Jtq0dwiucRXVlaisrISgiAoET5zc3O4du0anE6nwm7ZbDbJZBTQsD3SP28ScO1kBqp39S8Ic9YBrB19r3b2yNL8li9h2ZAHSqKJACYay4QYEVuj/ixq2KwSLuwiDdCkHotsF4pYuvBL+PMTA6jrVc/L4mIVgGUw08ilCN1XmoYcybO9oe43k1DP7VYZrH2Lhtdf7QOsPVx3A8wsLCxgdHQULS0tqKuru64p573SYMk+XM3Nzaivr1fWeas5gLtZPM9jfX0dDocD/f39YBhGmRR85aUlfOjXnkYslkVPbzkGz69DEID5uSTm56Rv9rKBJ0WJWFtLFkTSyMUwFNoP+hRmi2HyWii3GSsrMczORHHocBlmZyKIxQo9sKYmt7G+lkB9gxuT42FJC8ULGBvd0hiV9vUHcf7cigKGEvGcIkynKKC3rxJWqwFLS8Xd3SkK6OtXdV+zeV2Yw2FEa7sXNEWBy/GYno6UnGhkGIDnsONEY29fEIMXVgt0X4uLMSwuxhCosKGszAGbzYjygBNzMxFsbmqPd7wvgDOnJFSXzQp45aUlvPLSEj71x6dRX+/EO/5TC44eK8OJ+6phsRiUCJGmpiak02mF3ZqbmwPLsnAKUnSRvuVXYJWg+z2pDSqY9GO1InZ9FI6+CsCcxvX9JnIK9eJ5kgkjhF7ypCFFsHmy5YJkv0AwihSp8yvlwk4CHCdAhYh/q+2+uTPt+MZDnQAojeienAi0eo2ILEugjGYopMLEdU+r6vxoSF1jlk0gm83uqL0TBAGiKBa0CPfbg6+v2gdYe7jkG/WdKEEQcO3aNayvr6Orqws+n++G13Q3AQ3Zdjt69CjKysru6Xr0FQ6HsbKyAqvVip6eHgiCoMTe/MPfj+Lv/vYKMpkcjnX5cf5scSZmbS2JsnIb5uciyGYFHD1WDpOJxeyM2tZzOAxoaHDjzClVb8XzWi3UGx+qRSbDoaHRhdGRELJZ7XWpDNphNDK4fElitmSWTDYqtTuMsFhYPP/cfMnzbW3zYnIijK0t6abl91vQ2OQGxwkYGw2BF0QcPOjH6VOF7FgslsWFc6voOV6BkZEt1NY50dRsx+pqDMtL6uvc57fA4zFrfLTIiUaXy4S+/kpsb2fgcBoR3koXHKuxyY1YLKuwY8rjjW6UlVuwFYrDaKJw7kzpiUaX24S//MZFpFIcrFYWA/cFFRuImhonjEYjqqqqUFVVJbWBt7exfDlvPxFPaOKKCwHXztmCmrzA60Xh6IvcN4WdbRl0bx0hu4NHFk+254jzEfKPG2hlfzSdF7szqp5KhE3jdaVxYUdh608qOwACYFESqF8eehv+9f89AbktSH4vZImJQLOLRST/lrF6DYhvZJXnJ8PEMdMqGxzlNvHKK/NwOBxKO9jpdGq+fMpfMvUtwn0G6/VV+wBrj5W+RZhKpXZ49q2VrGMSRfGmQ5DvZotQDkROpVKKD5e+7iWDJbNqHo8HZrNZEbPzvIg/+sNX8bd/cwVOpxEtrU4kEkkcPerH1FREmZyTq38giPPnVCaGDG5uanajusaBbFbA6RJidUCaFHzheRUYWa0sOjrLYDQymJoMw+e3YGMjiZXlQt1XLidgciKMjs4ynD45j+pqB2pqnYjHshgdVY1Ku7oDBXqqzc0UNvM+V+UBK5qaPBBFEdU1diwuFB6L9NEaH1N1NrJonWYorK0mMDlR3MmepiXN1TNPz+b/TaGt3Qufz4L19QQmJ7bR0enH/Fy0KIs3Pb2NtbU4Gps8mJuNoLunAoLAYXJyG7GoCi6OHPXg6pVNcHltTjLJ4bln5/Hcs/P4w//xKvr7K9B9vAL3P1iN472VMBpZKXi6ksYErsFiNIKDCvzSyRRIuEK27QCtEJ0yMECaeI3ogY4OYBWI2kmBvJHVMFjQB0HrWoSkc7vewgE5okUoEEBMyF9nFkr2Mp0HQqBtUPRUtANa1ops/ZF/K3KNhBZUZAAqjtVLv4iv9N+HshZiOpBgCGmCpTNaidahWwVYVq8BiZDq3J4Mq+dz3yM9gIFXJkvlaWV5stTr9SrP3WewXt+1D7D2cN0JMBMOhzE0NISysjIcPHjwprPaZMZIFMU7mvEXj8cxODgIm82G/v7+AjGxXPcCYJGRPEePHkU4HEYqlQLP84jFcvj1Dz6Dl15cQFW1HTzH4eoV2TohCZZV2aLlxRiC1Q6cPrlc8lgGA43LFzewtZWG12dGU5Mn39YLIZHgCow75SINPLuPVyAey6KtzYfNzWQBq+PxmlFebsWF85KeSm6xAVD0Vz6/BUMX1ouK1QHJIV4QRM06amocqK5xIhbLYnxsE13dlSUnGjc2kigrs2BpOY5UModDh8tgt2snGs0WBu3tfs3UpCCIGCMmB+9/oBq5nICWVg9GRwqHAGR2TGbx5HOWgZrbbQJF8zhzqrSTfW2dE7OzMZw+vYqvf3UYTpcRb7i/Cg+/qRbHq935hWk3ZkFryCI+QwAKSvv862muCt53ehaKjNUxsuDJFqEenOn9uDK8wgYVHCdHrJkEWFwqv29pISJjAS23CBkVIIkU8TPMWj0V4cIuak5IO124fq0Xj/e+AQCFNAGIuTS5jXpOjJEAWzYCbHlUgGXzGRBbzyrPkVqMqvZOFEVFe7e0tISRkRFlCGh7exsulws0TSOZTO4awPr617+OL3zhC1hdXcWRI0fw1a9+Fb29vUWf+81vfhP/63/9L1y5cgUA0N3djU9/+tMln79fau0DrD1cu+mDJYoiFhYWMDY2hra2NtTU1NwSQJINGIsFne5WbWxs4OLFi6ipqUFra+uO67zbAIvjOFy+fBnRaFQRs0ciEWxsbGB5MYnPf24cVy5t4cBBLxbmI4jHed32UqyN1cqitc2HpYUYBk4EEY1mC0TgPb0VuHxxQwlb3gqlsRWS2npGI42+/krY7UaMjoZQqoo5r/v9FjQ1e5DL8YjFskgkchqQQlYqKcX2PPv0LChKahH6fBIbJrNMBw/6sLQcR0RnPrqQB0dmC4PDRwLIZnkc763A2Ngmojqj0K6eCly9rJ6rDIAACajVN7rB0BReebm0lcPAiSBeeXlROVejkdYANREiRAFF2TEZqA0MBHHq5LpqA5HOYnJiG8mktK66eivCWylEoyqbE41k8eMfzeDHP5pBq8WI/251Ih5Jg/SGLzAeJabWRIYGxe2gudJ/CSp4O+iQ4E4CeX17kWwfGhlQZHtRD8ZyOfXQBMBCHmDJU4Ei6wClsFZk9iB5RZwASIBFsJ0U8Z4R1c+Yrenj+HLXAxBF6fokQurrLUtYgwhENBRdIibHZCMyCd0qwCo2QUhRFFwuF1wuFxobG5HNZrG8vIyZmRlcuXIFw8PDeOaZZ2C323fF6Pj73/8+HnvsMTzxxBPo6+vD448/jkcffRRjY2NF81VfeOEFvPvd78aJEydgNpvxuc99Dm9+85tx9epVVFVV3fZ6fp5rH2DtsdK3CHeDweJ5HteuXcPGxgZ6enrg8XhueV8y43UnQI0oipidncXk5CQ6OjoQDAavu83dBFjpdBqDg4NgGAYDAwOKRi4YDGJ0JIWP/saLiMVzOHLUhmw2DYeTLQBYgCRqt9mNGB6SGCaZoXE4jGhr94KiAJOZxSsvLRZsK1dVtQNzc1Gs5nME6+qcqKxyIBrNYGxEAlw9x4szRnJbr6PTj/BWGpVBO2prnZifj2J5Sb3RWaws2tp8OJ3XfRVr6x07Vo5wOI1csXgYSOxYWZlVM21IUUBrqwc+vxUbG0mUl1tx+tQyBL1XVL4EUcTM9DYWF2Kw2Q043CZF/0xNqTE8AyeCOKVjArNZQQFqLa0e0BQFr88Cr89SkNFoMFA4cjSAU/lzJW0gDAYanZ1++MpMmJ3Z1oArsux2A+oqnEAYyCZzMBOkazaV1SiLtIaejKatl9O95wtAkb70U4NcaYC1k+8VbWQhpkpMChpZbb6i7MtF06A4CShRcnYOq7I4muxBirgglN4GhjTIJYB63nBre+5+/P173g5RzOdmOlkNg5XaVn/OEWwW+ZoimUBSp2UkwNaNTBAajUa43W6YTCYMDAzA6/ViZWUFP/jBD7C+vo5Dhw7hLW95C37xF38R9913H0ymG5tKlOvLX/4yPvjBD+IDH/gAAOCJJ57Ak08+iW9/+9v42Mc+VvD8v//7v9f8+1vf+hb+8R//Ec899xze+9733tSx91rtA6w9XLvBYKVSKQwNDYGiKOUbzu0UyWDtZvE8jytXrmBrawu9vb1wuVw3vJ67AbBkKwu5tUqK2f/P98bxP37vRXCcgK7uMlw4r7IvXi+LikozOJ7GzFQMDY0ebIVSmJ7aLjhGLJbFpYvr0o3+1SUc7PDB5TJjeTmGuVl1+oqMpJFrbi6qOLFXVtrQ2u5DMpGDy2UqOql3vLcSF4fXkM0KioYKkCwegkEbUqkcUileAYHFqrnVg2efnYUoyuaoZbBaDQpQk4OlSVAG5IHaeBjURBj9A0FMjIfR01sBLicUtPVaW73YDCWxlXfm1k80HjjgQ3WNQ3N99HX4aDmmJsJIEKP4NpsBnYe8MBppLC/F4faYCywn5MrlBFisBrz68go4TkBVlR3VNQ7EYmlMjG8jlxPhcDBwuVkszkUApwv6YT0uwytSKpHSpM6ANrDgCZE3bWA0TbJ0waCLvs23Q27h9Xyv9HqtEpJPyqi7FeXbhZRd1W9SotwWNKkrJMChqIGYZuJxm9aKQaPTEhBf7cUXjzyK4CEVoFk9Bg3ASmwRvldEQDhPDHqQAJFhi4Otm7VooCgKHR0d+PSnPw2z2Yz19XX80i/9En7yk5/gPe95Dz72sY/hIx/5yA3tE5DyXy9cuICPf/zjymM0TeORRx7BqVOnbmgfyWQSuVxOoxXbr+K1D7D2YMnGlbfLYIVCIVy8eBGBQAAHDhzYFfqaoqhd14bJzBBN0zhx4sRNfeO7GwBrZWUFV65cQUtLixIcLJ//n/7JafzlN4ZhtbJobnVqwBUAbG1x2NqSWKH2A1bwfBqBCiM4nsd2WHvjdHtMqKy049xZqQ147ara+gtW2VFb64LZyuD0yaUCt3S5KiptMFtYvJgXvJNWDjJQK2bcKdfcbAQUJSKd5pFKcug5XgGKkjIPZaBG05JFArmPTIbHpYvquQ/cVwWGobC1lQazEoP+5WIy0eg8VK6wTjJbRLb1RAG4dGm9QEcll81mAMPSim2FHP3D8VIMTzyew/HeSgwNFkb4JBI5DA2uwee3wOsxI5XiMHCiCuFwCmOjW5qW6sCJIE6fWlYeW1qKYynP9FksLPoGKgBI4NCThxYGHelkIt56aQ4gcoaR4bSpfEaLCWlCAC7oRFbZrBYwi/qJREJzRRfYMpQWxOuBHflc2mTQar1y+deClXiv8hK7JDLq2Yi0SBiLEnvWBD07oBG8Ez9HVwL4UtcJ5FKMJjuQtGLQs1nJbRWsZgkPLD5LtGWJo5FtxFvNIQQkYOP1evHOd74T73znOzXxWDdam5ub4HkegUBA83ggEMDo6OgN7eP3fu/3EAwG8cgjj9zUsfdi7QOsPVy3CmREUcTc3BwmJibQ3t6OmpqaXV3XbnphkaL7jo6OmwaBdxJgiaKIyclJzM3N4ciRI/D7/Yp5aDLJ4cP/z7O4fHkTD7yxBol4HBcvFp98A4AT90m+UPJNmqKAqmojvF4zIhEeAA2e09oukLWyHEddnRMvPDcPm82Arm4/WJbB5OSWwu60tnqxtZXCzIrabiGtHAwGCm+4vwocJ+LwkTKMXNO2yQCg85Afc7PqBJ7M6jAMhYMdPng8ZrAsjRdfKK2F6uoOYPDCqiKIt1ppNLd6YDIaMDEehigCVdV2RWBOltzW6+uvxPlzqwhWOXCk2o5oNIux0ZAy1VdWZoHTZdKYqYY2U0rL0GCg8cgv1CGRyKGqyl40Z7G6xg5RACbymixZm+XxmNHc4oEgirBYdm7VBoN2jF4LKSxgd40bSIogsAB4UTuQp4sdRCSWg494fkYXTmyz2ZDAtvr7dEYzZ8cT1gp6W4aCCURdkfYQBWwXgTIpA0N07kSFwaKJPqicQ6idPlT3rwl9pshj6duF0t8ql2zCP7zvIaTzej2SgTJYtNOBMsCiKCC5pYKaDNHOzRKtQ5543ZNTmDfDYOk/qxKJhMbuhqKom8qx3I367Gc/i+9973t44YUXbrtbsRdqH2Dt4boVJ3ey1Xb8+HG43e5dX9dueU8tLi5iZGRECWu+VdH9nQBYPM/j8uXLiEQi6Ovrg81mU8xDV5YTeN9//TFGR0Joa/Pg4tAKIhHJK+nQIR+MRhqTecdzg4HC0WMVmhBjQLp3LS1msbSYRVOTDfFEGj6fCXaHEzPTcY2HlcXKor3dp7A9iYS2TdbW7kVNrQOLCzFNu48sp9OImlonXnlZXYfNlndoz+uZmprcGBpcQy5XeD15XjJBzeWd1yuDdtTVOZFM5jSeWwMnqnDmtFZPlUwKuDQsgbyqajsqK+0wGBg0NrmLtkpJPdXCfBQL89IN1+4woq3NC7OFxcZ6sqD1KBdFAT09FfhpPpwaAKqqJJ1ZIr/e2joXtrZSCjglKxxOY/DCKrp7KvKtWj9cLhNWV+OKFxcAHOz0Y0FnB7G1lgJv106S8aBAeqLrL286K5AdM4yOhtFG2CnxOm2a3W5HEipgTCdTavONZbQidx3A0k9Gauwh9GyXoGW3ZIBFkaDKyAAcILIGUEL+WpJvY8LRndJE45BPIkCNaAWYBPhcJf78/neDSxkggzQiqQeMUd3e7CAE6x6DBmCRrcMMYY/ClQBbt+riDkgA63Z9sPx+PxiGwdqatjW/trZ23czVL37xi/jsZz+Ln/70pzh8+PBtrWOv1D7A2oMltwgZhoEoihAE4YaYnWQyiaGhIbAse9Ottpup220RCoKAsbExLC8v35TJabG6EwBL9gmjaVojZhdFEUODG/jV9/8YmxspdHWV4/LlDYUFIq0RKErKC/R5zUrMTbHq66/EhfNSC2ttVboBmEw0mlssMJuNiMU4sKyhZNSLKAJerxk/++k8BEFEoMKG+noX0mkOoyObyGQEBIN2GIwMrl7ROsSTQG3gviqENlPoOV6JjQ3JT4osfazNynJc8dSyWll0HvLD57di6MJaSbF6c4sbke2sRusUqLChoUFa7/hYCIcOBwrE6nLFY1kkkzlMToYRjWSkiUa/BRvr6kSj0Ujj0JFyRawuF9nW6+6RblQ+nxnT9DY2NrSg1Gxh0NbuU4xYSWd9eb1GE4OLQ2sFXlssBfCU9vWY5kVoJEw0BewAuPSX78L5VXQQmE2vuTIbjMjl0Y/IUKCIrpSgnzDU5xTmdmCwSlhHaFgrIyXhHzPBQjGk75Z6bUWkCQarlBWDA6LA4G/+r/dh7ZoJVi9hxZAhwCDxZUzPZskAy2CmkUuqx0kRxqIk2MoRLejbAVi7EZVjNBrR3d2N5557Du94xzsASJ+Xzz33HD784Q+X3O7zn/88/vRP/xRPP/00enp6bmsNe6n2AdYeLvkNzHHcdanmzc1NXLx4EZWVlWhvb98VvVWpup0WYTabxcWLF5HJZHYMlb6ZtewmwCLzDjs7OzVi9n/95yn87d9cRmOjG80tTpw+WVoAXlvrxMZaAsN5YKQHPtmsgP6BqqJTfpmMgMmJFGprKcTiOVgtOXQediIWFTA3q075MQyF472VGkCytprA2qqkhbFYWDz8pmrkOAGjJVqPLEuhq7uiQJNVXm5FQ6MbmSwHgRcwOxNFNFo8VYDnBVAUrVg51NRY4HKzSKcZBagdPlKGqcltjdCcXK/FyuLgwTJkMhz6+oMaF3u5urryRqf5G+342BYwJv2urMyK1jYPTGZ2R0PW472VGB7SsnRyRmNoK4W1tQQqAjZcJMxe9eutr3fi1ZcXwRpoHDlaDrOFxcJcFMvLcbCgIOgF7nrGihM1n+x6Bwf9q5nXTQmOXt1EHXFvJ+NtDBYTuLQKGOJJvaO8ThC/g3M76T5P/o4m0CItr4NoR1Gk/YIYV8kqigRb5OtA3bco2PDPj70b48/ZQFFAaisLeQfZBGHFQIA/ks3SxOT4jIgs5WNyWAopwhqEZLnSkd0BWPF4fFd8sB577DG8733vQ09PD3p7e/H4448jkUgoU4Xvfe97UVVVhc985jMAgM997nP4xCc+ge9+97uor6/H6qr0BcZut+87y1+n9gHWHi75DbwTmBFFETMzM5iamsLBgwfviu/JrbYIY7EYBgcHlcy+3fDR2k2Atbq6isuXL6OpqQl1dXUaMfsXP3cOf/74BZjMDFpbnbhyOYymZicCAQdWVxOaVlexPEAS+Hh9ZgwcLkcqlYPPb1F0Q2QdPVaOiXFp8i0MYCkfJeN2s6gMmgGKhtFgVCwUitWBgz6cfHUZ6TQHigKaWzwoK7MqZqNOpxG1dU5NsLRc6+tJrK8n0dNbgbGJbTQ2uWG2sJid1gIft9uEyqCqpxJFYGEhhYW8RMvvt6CrO4CtULrAcVwur88Mn89SoMlqbHQjUGFFOJyBy2XAubOl2TFRFLG6msDU5DaMRhqHD5fBajNorCf0YnW5pia3MTW5jUDAimDQDpvNiJ7jFRgf2yoAlQMnVFDM82qwNSBNYLY7rKB1bUcdPoLRrGbgFfs9a9AyXPrKpDmAuI/HttNKPDJl0IIkl8uF5JIaSRONRDWAS0Of6e0giPcVaXFAmxgFBVJM/gcT6XdFxuGQ7C3p3F48g3LoB2/G6W9J028WjwGpLRX8pGMkm0WsjVi2gYzJcbKI5LG2zWdEbC0vzNeBrQQhir/XLUIAeNe73oWNjQ184hOfwOrqKo4ePYqnnnpKEb7Pz89rvkD/xV/8BbLZLN75zndq9vPJT34Sf/RHf3Tb6/l5rn2AtQdLpr/lib1SOiyO43DlyhVsb2/flLXB7dattAjX1tZw6dIl1NfXo7m5eddc4HdDcC+KIqanpzE9PY3Dhw+jrKwMHMeB4zhkMwJ+8yM/w5M/moLPZ4HdQePyJakdNTUZxdSkao1QV++C1cri5KtLSJdwPC8rs8DlNiuxNrJ5p99vwdqaBBD6TwRx9vRKUTCxvc2BNXAwmyisr8fQ1GyB1WrE0lJGoyfSG4yKoiTilltp7Qe88JdZkYjnYLGySBWZ1CMBCQkkmprdKC+3IZXOYSuUKinMB4CWNq8Sa6MAH7sB83MS8KmusQMiVeAuD0ixNtPT2zhxogojIyF091RI2ZQ64FNb60Qux2NqchuAJJS/RBiV1tY60H7Ah6WlOBiGUoTyZNXVu5BO5TSTmyxLK/qrlZU4KittJZ3oAWm6cmMlgUZK14ajtIApnuTgJ4hbHakEhmVA8lj6d4rDpgVo4AQlvm9lLQW/RgOl3dpmtiCbd00XWQoUeS10zJs2+FndD2VkFI9QShaxG8hblQRoBViI0GcaFGLE2ZBfKqTjzJ78ZZz6VgcA6bVgdWsBViKk/s1zxBStSGJEYnyTjMkxu1gFYJFgy2Cmkc171VEUYPffmCid5/mCdIndAlgA8OEPf7hkS/CFF17Q/Ht2dnZXjrkXax9g7fEqZdWQSCQwNDQEo9GIEydO3NVplZsBNSR4OXTo0HWFmreyltthsOShgHA4jL6+PtjtdkVvtb6ewmc/dQZXLm+gscmN7e0k5maLi8jX1hKor3fhZ5opPxoTE2EljLi5xY1oJKtxEpd9osbHpBv0Aw/WIJvlceiwNOWnD2yWdUyLi9JNcmoyBSAFigKCQSN8fhPsdsuOQKCl1YPNjRRGRySRuMnM4PDRclgtLGZmIthYT+B4X6Fxp1xTk9tgaBqboSQgAse6yhCLxbG8lFUczxmGQs9xbetRD3wGTgTBsDS2QikwK1RBK4xhKHT3VOBk/lxk+wqWpdHR6YfDaUIuy2NqKoztcHFGhGEoVFTaFZDncBjR0uYFy1CYnAxjK5RG+wEvVlYSBU70HCfg2tVNsCyFY10VmJ2Non8giFRK1bfJdeCgD0uLMaRzDAS7ltnI6o1AdWvUM1jJJCcZnefLbjdACfmDZGJKDt4RaTDShCKBqaamtlFJ7JuEW6zZCD6unnM0GtWooTQB1cSGtIEmAFbeD4ullPxnKm8aylN2UDKQopwARUxyUqRzew7xteP4i7ccQ30/AZCIdp/JziBDmPamienAXIa8ooS/FXFhNM7tBNgi24hWnxGM4cakFTzPF0zp7WcRvv5qH2Dt8SrGFslRMtXV1Whtbb2jeqtSa7oRUEMybH19fXA6ndfd5lbWcqtmrJlMBoODg6AoCgMDA2BZVgFX165u4f3/9UmsriZw5GgZ1tejCFaZUVHhwNjolgYM2Gwsmlu8irCaFI/TtORDFQzasbgQw/p6suhabDYWza1evPSian8gicfLYDBIU4m1tdKxi/lCiSKwvS3A5WZw6uQ6XC4GwSozRLCYnY4hnZ+aOtZVjtGRLaRS6j4yaR6X8gyV1cqif6AKoihNJ46PbRW01I52BTA2ElL2sZUHkAYDjc5DZXA6jaAZakd7g6NdAQwPrSv7cLlMaGn1KJ5b2RyP1lZv0fYlxwm4emUTR4+VY2x0C16vGe3tfiQTWYyOqhONFitbsI9YLItBIn/woYfrkM3y4HJCAcAC8oL3Np8C7mRhv8XC4uixMphMDCCKuHhxA+k0B4PFCkHHYIk6BkuyTiAYmJJXSapkIidZReXLZmUhT9ZxAjSmpqkMD6jen9hYT6KSeNuFN5IKNpPMQ9VztjsdyK6obbxsPKlOJxLnRE4bUnweabHSKYm0GVSegRJpKyFqtwHE5CP5czZpxVceeAsEntaI8Ml2n8Vt0ACsxBYpUie0WaRxKnFdWMKIjARuFpfaRrzR9iBwZ1uE+3X3ah9g7cHSx+XIAIJkg240SuZO1I20CFOpFAYHB5WJxjvFsN0qgxWNRjE4OAiPx4POzk4AUMTsT/14Fh/98E+RSnE43luO8+ek4N+VZelm5HKZ0NLmAUQpH1CEqGmhkSUIItxuE57/mTTlJ9sFxBM5jFzbBMeJSnSOXlidTHLqlN+JILa20jh6LIC11QSmdPYG5eUWOJwmjFyTHo9EeEQikvbGYKDQ2GRBWbkFM9NRDbgiy++3wO0xaywlvF7JE4rjRYyNbKLzcDnOn10pYJuk6ydgZSWOTMaMifEwamudqKp2IJKP75G3kT2uyH1EIhllurCszIIDB32gKAoNDS7MzBROYZL7ICcEbTYDOjrLYDYzyGR45foVq57jFXj5pQXFhLSs3IrGRheyWQGjoyEYDQwqK21F/7apFIfhoTUc763A8NA6amqcqKiwIbCQhpjVspyMgQHpB5XLCRpnApfbBPCFdhFyGRgtQOMznLI9T1Fgd5hI1LcXt0MpWPPEy3YsBxIOsAwDUnHGEGAnGo3AreyUjMzJBz3LOYQGBwGw1JPUBj07AEoCcqJowD/95huxvSi123iiZcmwWj2VXAYLjRxhIJqKFrdfID8WaKY4s0W2EW/UZBQoLXLfB1ivr9oHWHu8ZDDDcRwuXbqEWCx2x9igm11Tqdra2sLw8PCuOsiXqlsBWLIerLGxEfX19RAEARzHgaIofOdvruKTv/8yWJbC0WM+nDtbeHONRDI4f3YVbe1exONZlAdsGDgRxNycNsuPYSj06Kb8SDBgdxhxvK8SXFbrgq49v7xruq5dJ9sFpFIcUqkctsMZRYOkL44T4fM5ceaUBDYqg0b4/GYkYgJmZqS11Dc4kU7zBUHIW1tphQG67w1ViEaz6OmtxPRUCBvrWsanttYJjletHObno5jPe1g5nUa0tnnh9ppx/kxxgAZIPlkURWnE+7K+LZnkMDa6ia7u4hmLgMQerqzEYTAwWFyISsL+cis2N1KYGFd9s4q52W+sJ7GRZxirqu2ornaCoiUXffLvquyD0KjJerEqqw2US3tuqTSvEaXrX63h7QyqCYbK6TSBDEI2GWjNVuRtPc2JMBFSIKtN207UIyxi4A7haBZE0g2Wl+MqiAI0aM1utyqkUywRgWKsks0zXrI3BEsAKZrMHiTAC2WHLHi/9G//H1z5kRsyo8cR2kWSgSKtGKweIyIp9fokyZgcgs3iifWTAxYk2GIIsOWsuHWAlcvlkM1m9wHW66z2AdYeL4ZhkEgkcOrUKZjNZgwMDNx1d2B97aTBmp+fx9jYGNra2lBbW3tX1nKjAIucuDx06BDKy8uVScFcTsTvPPYz/NMPx9HQ6IK/jEUolITJRGu0NnL1HK/A5csbyKR5Tduvvt6FyqAd0WgGDEPhzA5Tfq2tHpx+dQmpFJd3SvfD5TZheTGGubkorFYWrW3eopOC8lTikaPl2AqlUVvnRH2jC1OT25qpRLOZwcEOP86dVZmcleUsVpalm5LDyaCl1QaOo7G6mig4DpAPQj4WwKuvaAFJba0DVdVORCJpgAKWFuNF22yABHxomsJPn57VxffEMZf3CWtp9SAUKjT/XFlJYGUlAYqSxPuplGTlMDUZLjBWbWxyIxbNYnVFQgOksF+O0nG5TTj5Sun2ZV2dE5ksjzOnlzWPBeUw7dEQenuDijaMLJaiCoxBjWYWpChdP7ugb8HGYhlNS9Coy90hNVeSP5X6XozGtO1Ep117bK1eS8uMzc9GIPsSiwBEjlc08ixh0+ByO4G1JYgUBZqX/t6ZdAQsAIE2qQCQVgGISAY955uU8Y1u/P2vtYHP8AoOzBBWDCSbRbJOZieLSP5PY7QyGlCVJLyusiX2RYItsltwOy3CREJ67+xrsF5ftQ+w9mCRb3qO4zAzM4O6ujq0trbu2vTd7VQx3ZMgCBgZGcHq6iq6u7vvWtDojQIsQRBw5coVhEIh9Pb2wuFwKHqrrVAav/aBp3D+3Crq6pxIxNOYmZZuHGYzi6PH/DCZGMWdfeC+KpwmYm/Imp2NIJvjYTAwiEUz6O2rBMcVhhjrHc95XtQYWnYe8sPvt2BjIwWGKRSAA0BffxDnz0lskAw0yKnE7e00BAE7tsna2sswPLgOjhNgMFBoaLTAZjNibS2DjfW04gB//mxhrM38fAzz8zF0dQewsBBDa6u36JSf1cqihdBCkfE9gMQQdXT4sLWVVsCWvkwmGh2dZZr2pWI9kWeojEYa8zpndbIi22mIIvDs07OazMOFhSgWFySGqrXNi431JMJhLciTw7QpSmK/Mmkex3srMTmpDjEA0ge20axlbBMpDmQvzu4wgtQ+6Uv/Dk/rRe3EXSGZ5uEktNb6dwKXEzQ+nkaC/tK/pMiPljSvdV7YWIujLP+zTEjTDnVRLJUFRCCaSMKTP1eBHO8j6SjKDFFw4Il3vBlWjxHxVfVakDmCZHYgaSFhtBFsltegBVgEm0XmE+Y0zBYBtgi0ezstQhlg3a6v337d3doHWHu05By8SCSCQCCAtra2e70kpfQtwmw2i6GhIXAchxMnTsBiseyw9e7WjQCsTCaDoaEhiKKoMIAyuJoY38Z7f+VJLC3G0HnIh+mpbWUSDgDSaQ7DeW2UyczggQdrwHECGhqLx7wcOOjD6koCy2Hphi2DCpOJweEj5bDZWBiNzI5Zfk3NbqyvJXHlsgS45PYaKGB8VAIvpB8TWfJUYjrlBM8L4AUR/QNBJJOqwalc+jZZLidiZlqaSpTWYYbTaUIkkgFFFTItADSWEnJ7TZ3yMyK8lYYglNaoAUB1tQPP/0zSQskaKoNBiu8JbabgdBpRXeMsAIqk9URXdwArKwkcOOgrCmhlwbssVpczD+WqqXWirc2DUCiN6Vhx8COBsnKcJJg8mqbQ0uoGa8ghEQe8nAkcr20nFsTT6PbrdGoBl9WiZZ0YHeIiuSDWrArei+2by+oAFrEvq90AiCogIW2wdMOrWF6MoKxc+nlxYRu1LEBZ1B0b6QwgAHYimiuZjsOYJ3Ryuazi5CCCxanvvBPLl00ob2UVgKXPEcySwxzERSTbeiZCm2XxGDRu7UkiTJ300CL3S/pp3U6LMJFIwGq1Fuiy9uu1XfsAaw9WLpfD4OAgEokEAoHAay60k2wRymJxt9uN7u7uXTEPvdm17ASwYrEYLly4ALfbjUOHDgGAAq6e/9kCPv67L6KqyoHmZgfOn1tFMll8X16fGeXlNs2Un6wNSiRyGB3ZxNFjFbh0cV1xGicrk+ExMx1GQ4Mbpy4tS15SARtCGymME9og0mBUrmhUjZex2Vg88GANcjkBNTUOLCzECo51sEPyfJLbdasr8rdrdSrRaGLw8oul22TNLe68rktilBwOBsEqExiaxcxsAqkkXxLkyVN+NTUO8IIImqYwcKIKsVgGoyMhjQ/VifuqNKxUIpHTxA1191TA6TRiYaEwrFmuvv4gzp2VQJ485UeajW5uJkDTzI4gL1BhxYsvLCCXExQrB4amFIbKamXR1OwpMEMVBAmkA8CRo+UQlnMwu7XvAT3oiUazGhuGmO7frA5RkR1CfXB0PMlrPLXMunakPgORdCHYjuYQJNqJZuJAnI4pN9DqftZX46itBhbXUjjQmD9DTvr7EF1BOBzq51Y6k4Ah/71rbdqBH/6mJB/Q2CfocgRJBopks0gyjBSpW90qwDJYtDE5JNjKEPvNJNSfKzqIi3GdEgShAGDttwdff7UPsPZgJRIJJQdvZmYGuVzu+hvdxZIZLNn5vLGxEY2NjfekfbkTwFpfX8fFixfR0NCAhoYGCIIAnuchiiK+9VeX8ak/PglAREWFGS++sAmDgcbhI2WwWA2YnYkozuv1DU5kMhIrQpasDQKA+x+oRjLF4fCRMoyPhRGJaFmQyqAdJiOj+EDJ7uGAFPPS2OSGzWbA6VNLRW0YgDzIK7NqQF5tnRNVVQ5EImmMjoTQ1VOByxc3ioI8SSQeQlOzB2fPrKCt3Qufz1IwlXj4aDmmJrQgLxbjMTYqMVRmM4XDR2yIx+MoKzdjY71wAq6t3Yu1tYTiT7WYB4IOh8TG0bQEBl7ewcqhts6FxYWo4hwvTfm5kcnyGB3ZRDrFFxWrA6rnVqDCJlkpgMPAiSpEIukCm43+gSDOnFYd3vVWDse6AvB4zJibK50pKUfwDJjtiLMZgPD81bcEC94lugfSiZympWgg23q64Oid2nwAYGBVnVVWB7D07xqB2Jmoi80xMuqzDfmft/Kt2EiagT+/t+WVbdTU5J9Iq+fscEjskCAa8G+f7Yd80jlBfY7FpQVYGvE6OflKOl4QJ2Syk61D1d+KMVLIRAmLB4LlkmNyjDYG5a03JlAXRbEog7UvcH/91T7A2oPl8Xhw7NgxABKYSaWKm1veq6JpGolEApcvX8bhw4eVCId7tRY9wBJFEbOzs5icnERnZycCgYAiZud5Eb//sZfx3f99DQ6HAcEqKwYvSK24XE7QTPM1NbvR0ODG2loCszPFp/yMRhpHjgY0QEERrLuMWFyIwWozYGMjqbAr+trcTKK52Y2fPTcHs5nFsa4AjEYaU5Pbiraqrs4ptb5GtzTbzs9FMT8nsQcPPFiDVIrDocNlGBsNIRbTAnPZykE+xzFiXxWVUlaixcLi9KnlklYOcrvu0kUyANmAsjILkkkRM9MxHD1WjpFrW0inC/cRi2Vx5fI6OjrL8OorS2g/4IPHY8bKSgyzMypLdeCgD8tLcQ1QJaf8LBYGDz9Sh0Q8h0CFTQHDZNU3OJFMcMr1kf9Pem6ZzcyOIK+s3IpQKKWwaoGAFfUNbsRiSUxObCOb1QI01gyA1qKeRJLTaKj0k376GVtG56NF7i4natt8eoCVyfCau4YGjOn8uPStS5Y4biKltZIg8p3hsEsL4PLriGYZ+PO/29yMKABrO7IFOcddpKSg58kzb0d8sRrANgAtGyUwhBjfymgYqEys+HQgRfQ1yUlDfUxOdKXQuR0A4pvS41VHnJrpwp1K/rwhAdZu5RDu192tfYC1x6uUk/u9Ko7jMD8/j0wmgxMnTsDhuHFa/U6UHmAJgoCrV69ic3OzQMweiWTxR3/4KuZmI2hodCGdzmBstDQrUVZmxfM/mwPPiyp7kuEwck1y8fZ4zaiosCm6HrlIwXp3TwXC4TTa2nwKy0TiQYuVRXu7TzEpTac5TYustc2L6ho71tdSuHK5OMiTXNMrNcyWbPrpcBgxNxeB2cwiEc+WtHJYXUmgodGN5382D6uVxYGDLogih7VVDuE8CxWosMFiZjVifABYW81hbVW6OXYcsiGZSqCxyYbZmbhGzwZI4CZYZVf0VCQrWBm0o67OCaOJxuCFNcRjxZlbk4nGgYN+/Oync8pjjY1uVFTYsBVOY2w0hPYDhQBNrkgkgwvnV9HbF8TJV5eUicaVlThmCc+tujon0mkVoAHA2lpSYdRMJgaPvLka8ZgE8lZXEmCLsLgsqzUWTSZympag02kERHWd+khAUpie5kTYyCFiWguaBL0bPvGzQGvXoWfOrGb19/o0IQOlvmhZeR+09FiCU1GSw0UET7PqdO3WVghGkwvffO9B+GrV50iicIlpktqF0t+csYnIEZ68qW0yJod4AxEidZotLoQ3Ow0KwLJ6jYgsS8dzVJgQy+u/arrcuNGSP4/3GazXf+0DrD1et5L7d6cqmUwqzucWi+WegytAC7BksT3P8wVi9pmZGN7/X3+EmekIDhzwIryVgNdrRF9/JebnYxp2SfaeIu0RtOwJiwfeWAWKgkYorS8yD1AWxLs9JrS0eMELIjbXkzCaGAVQ6UsUJUDyykuLyGYFhWVKJiWT0lxOhN1uQGOTW2MpAEhsnAzIDh0uQybDo7HJDa/PgtGRkIa9YFkKXd1qrE0yyWHkmgQ0KEpq9wWDdoTDaUXwX6xOnKjSWBewLIX6BjMcDhM21rMQRQpmi6FkduHKchx1dU68+vISzGYWXd0BsAZaYz0hMWiOAsG77EMlXfcgeEFEs9WDsdEQ4nEtUJPF6vI1I9dTWWlDbb0LDANMjm+XdN4HgK6uAH76jAryGhpdcGeMsOiictJpTiM011ciltW0BFk9wNJH4RDF62goPTgj9VuJDA83IeekdeCM4kQFkemZMTNL+HCJ0ueRK681yxAcnNUqgZccR8HpVa+72ZLCX/3+I0hus9iOh2HN39pyRCvbYrNAHrCwuU1Ib0j7olggTbT4NKHPJJtFnGup1qHZpVo8eKrNCsCqPnbjOa48z4OiKI0kIplM7jNYr8PaB1h7sEo5ud/LCoVCGB4eRjAYRHl5OS5fvnyvlwRAFdzH43FcuHABTqcThw4dAkVRCrg6+eoKPvSrTyESyaCrpxyXhjfAcSK2tzlMT0s3UJkB2Y6kYTDQRb2n5Gpu8WDowhpisawSheN2m7G8JPlXsSyFrp6KogLw7XAG586uoLHJDUEQYbGw6B8IYnY2oojR5dLri1ZXEspzbDYD+voDMBjpHUFPb18QgxdWFbdyAPB4zGhpldzZF+ejCFTYikbSABLIMxoZnD27gkQ8p4K8FIfRfFaiDND0vlAcJ2J2Jg0gjWCVGQwrwOFg0NTswMx0DHrpHHm+ZNyQzOQFAlbkcjxOnyq+Vvl8zxJGpgYDjc78ROPiQgzhcBr1De4CsbpcKysJlJVbFe8suV07PbWNjQ3p5s8wkMxOda+RmekI0i43REbrRcXqonH0JJee8zKyWuBDtgT1AMtq0+q7zCata7yJwHp63yu99YeJuNvov9JZDCLxs/SHS+fNPsmJQ7dLWks4aoI3IP0+naGxsmHH5PeOA1A9SQHg0uA6vPleZCaj/sJCmK3avAbE19XfxUOqZEITk0OcD+ltTE4dkswWQ8Tn1HTdHMCiaVrzOb3v4v76rH2AtUeLoiiIonjPGSxRFDE3N4eJiQkcOHAA1dXViEQitxWwvJslA6zTp0+jrq4Ozc3N4DgOHMdBFEX80w8n8Ed/+Aqi0Qx6jpfh/LniYGR6ehvpNAejiUEinkNffxDpjAQiSKPR/oEgzp9TAYsgaD2dWts8qKp2Yn0tUdK/6sjRckxOhpGI57C4qE4BNjW7UV5uQyiUgMttLirelqui0oaxsS1srCe1II8w7iwlAA+HJXf2QMAKt8cMCkBvXwWmJkMIhbRsT29fJYYG16R4FxSCvGNdAdgdxh1BXuchP+ZmJX+qhTwYsNkZVFebwTAsFheSaD/gL3m+oghk0hzGx8NYW00gELCiodGNVJrD2EgI6bz7d7GpxlxOwJUrUkvT6zOjtdULk5lBR6cfo0R8j1w9x6VJUNnOgmQXq6rNqK31wmRi8cLz80XXylLSpCdZvO69ogdUes0VRbS99JN/epAUjWU1YC6X5TVsGQma9OCsYB2EbxVNxNQIImAg1mhhpettMkj/N1ikPaWyNKxmLr9uC2SAtB0x4cdfewgQJHBjJBqXjKAe59qVLbjzJhSJpNoStLiMCsCiWQq5OBGxtKkyz1nCBZ40c6UJWo80LM3EpbVa3Cx8jTfuX7WfQ/jzU/sAa4/X7YQZ327JeqaNjQ309PTA4/Eoa3ottC1FUcTKygoEQUBnZycqKiqQy+Xyk4LAH3/iJL79rUtwuow43utHNJpAWZkZGxuFU28HDvqwtprAcr5VuLGhtgOPdanWBjsFGFdV25FJ83j+Oalt5HKZ0NommW/KovO+gWDJLL+pyW1srCdRU+vE7HQUff1BaWLu2qYCIoDCKT89yKurc6KlzYvVlThYltLYIsjV0OhCMpHD+JhWNN/Y6EJFhR2hrRR8PjNOvlqayTNbWIRCaZw5vaK0En0+C1ZXE0pLVA9Y5ErEeYyNJmA0Uqirt2BtLYxDh13Y2MhidUU71NF+wIuVlYRiO0HqoKTQ5XKUl1sxPFTaUDUYtINmKAwSgEn2F6MoYGI8jPYDPpw9s6KYv+orGuERiWRx7eqy5Arf7AaXEzA2GkIiP+5vNbLIZrTGonog49JprvTaahM5+Sdqfa+k1hfx3tMtldE9wIjqAgxGLbvldGrF9iZiHTmi9ZbiAVf+d4IoKmyW1SStIydI+9yOG1FBSeA7tE1BHn2JRb0Y//5h6XzAK+1BADAQV4cjXiMjo1uoyKdWx9OEaa3XgPi6+m8uocYIRTaIoOok4ZxP/D1J79OtGek1VH3MdVMT0MUAVjKZ3AdYr8PaB1h7vO6VyF025xQEASdOnNB4ccmskSiK98xZXhAEXLt2DWtr8nRXALlcDoIgIB7P4Tc+9Cye/9k8ygNWmEzA2TOqMFv2oNpYT2ByYhvHeytL+lelUhxGR0Nob/fh/LnVgnagXO0HJIBGOoBHIhlFAG800nj4kTokkzmUB2xFJwqDQTsMBhpX84yLDPLIyUKWYXDmzLKm5UeWw2GA02XCT5+Zzf/biLZ2LyiKwthoCNFoFp2HyjA7G0G8iOP59HQEs7MRHO8NYnR0S3GiHxkJIUXYR9TWOpHjBKWVJoraqcTKShsOHS7D+lppDZPbbUJFpZ0QukvXrqzcgEDAjHQasFpNGB/bLjqRCAC5HA/WQOOZp6XzbW7xoKzMitCm6i8mx+dsLGvXQvqLnXhDFcJbafT1V2J1JVEQMO3zmeH2mBWBf2gzpejCZFf48oAV9FAcvLgzYxXXaa5sFq1ZKAmSOAEapXoqI2juCnadSSmpwdKzX8k0rwN+6pN5EWCJ45DTfRlBfV6KeIt4nbLYW1p7NGVARf536ay6s+997TBEUdqHoItKNBMnxxLYkLxmW5EMLHmdV5L4ssmaaOQSxLXOGpWdx7bUdnsmpR4wtiFdK3e1GduL0uvtZvRXQOmg530N1uuv9gHWHq97wWBFIhEMDQ3B4/Ggs7Oz4MNE/ve9AljZbBbDw8PI5XI4fvw4Tp48iUwmA4qisLgQx/v+65OYGA+jucWNzY0E1te0bS/Sg+qBB2uQzfJoa/cqwnGyysstcLrMSquIZIpqahyoqnHAZGRw9swyUqniQNhsYXCwxNTbZiiF8bEttLV7sbGRxPJyIbsmTxYOnKjCyZOLaGmVonBWVuKYmVaBQCBghdVm0AjvYzEVRLAsjUd+oQ6pFAeP21QUYFmsLNravIoA/GxIdaI/crQcFgsrmabObCseV8WqvsGtgB6bzYDOQ2VgWQaTk1vYCqVRUWmDycgUeIsBwMZ6DhvrOXR0OjEzHUZtnQmswYaFuQRihMDZamXR3OLRxPiQ2YN+vwWHj5YjkchiZaW4RQYA9A9UadzZAQkgerxALkchk6Eg8Cg5gZnNCrDaDHj+uXn8gssDi0X7frleSzCX5gAi/IDUTelejrDoLB7iOpNSp90AiDllW5L90hNzybgK9HKgNIJ4i4VVjkOSj2Qsp4WVfu/1UPnnqb1JjpcA0cKCHUM/OoS8CTzSOR72/G2NY0QYeaJ9R4jlSeuKaCwDS/4CbYRT8OU1W1la0DyP9M2ieRV4JrbzflgmIJTXXDorVYB1MxOEQOkW4b20q9mvW6t9gLVHS9ZgsSwLURQhCAJoWu+Ys/u1vLyMq1evorm5GfX19UUBlPzhIos972bF43EMDg7Cbrejq6tLYfcWFhYwPwf81kdfRKDCjgffWI0rl9ewvV161P/Q4XKNtYHNbsChIz4wtMTGlAesiESyyg1bXwsLMVTXOvHSiwtwuU04dLi8IKbF57fA57PsOPX2hjdUgxNEWKwGJBM5TTsQyLuSHylX9EXjY1sYH5N+J1sbiCIwPx/RAC599fZV4qfPqiCvPGBEXZ0biTiP0dEQ3B4zfD5LUT1VJsPj4vA6uroCGLkWQlW1HQcO+BHKA0S55GBoUgtFCtZpmsJ991WBNdBFXejlIvVjsTHppsgwQG2dCS6XGfE4D5Y1aHzL9FVT68Crrywik+bzUUWSiexcfqCAZSkc7Qrg9KlC7ZdkIgs0NLgAUURZuQVV1XYlj1KzVkL7xVKQWoQEmVFgw6A7Fqt7gGzrMUYtuxXThTnri8/yCqqSzEIJCxP9cQmgl+ZEWIm7DRnuTEYCZkQZTAFl+RYhS0l/nwTx3cDhkRjvf/3OcQi8ui+eEpS2Zg6CRo9loVjld0zBVcpvT7B7iWwOjvzJ8owIhgBrCTJyZ0t63F1rRmhCWmQipb72godvrrW3r8H6+al9gLXH626BGVEUMT4+joWFBRw9ehRlZWUlnyuvg+d5GAyGks/b7drc3MTw8DBqa2vR0tKitClbW1vxD39/FV/7yhQ4TkRZOYuXXlwDRUn6HY/Homnp+fwW+P0WhdmRKxHPKQ7e3T0VyGZ5+P1WGAw0lpe0DIjBQOHoMdXaYDucUSbxZEDkdpuwsZEsaUsASDfnV19dVGwTJM2XNB04NbkNnhMQrLIXrFWuleU4ysqtmJoMg6IodB+vAA1gfFx1k5d9sk7qROTra1msr0lg6sBBHzxeMzJpHna7ocDaAJAE/rJGiWQB/X4LGpvd4HMCBAFFg6HlOnDQh0uXNpRAZjluKJnMYXQkhFxOQF9/sKjgneeB+bkMysqlSTxByKCj04FslsL0VBRkJ723L4gL51WtWybDa8BYW7sX1dUOLC3FS+YstrV7sboqab/m56XXDkUBLa0eJYjbX2bRgEkWFDgdQ8URoAcAHDYDyDgbi0kFQvq2XiLFwUOwWzYdWCuYSCQE9cmMABthFur2mAFOBYeMrp1IViyWAfJ57QZCKU/lReLRLK2EP7vt0t+SlPpFomnEEwZc/WEfnA4jkO+mk1cmI3Cw5QEWBwGsSPhpmY2yY4ME9jh5e8JWwkgpz0nynAq2KBHIe2U5K02KB5azzKIALJozAkjB5KZwaeYcvBEvfD4ffD7fdbNUS2mw9luEr7/aB1h7vOQ3MsdxdwzM5HI5XLp0CYlEAv39/df9JiaPKN9Nbdj8/DzGxsZw8OBBVFZWasTs3/n2PP7ia5Mwmmh0tDtx6aLE4ogiMDqisis1NQ40t3qQTHA4d7a0eHvgRBXOnF7WiGPrG1wIVkri79XVOKqqnAUGo3JJgm4Rg4NriMeyeV2QBRsbkvs3oHpt6afeUinVaLSmxoGygNRKq29wapzO5errr8SF82uKJutCHojJbvIejwk0TePll0qHS0si8rgCBA0GSVNksxkwNxfFynK8wOOKLNlt3uU2YWkxjqPHymE2s5ieCmN9Xb2hd/dU4MplbYwPGTfkdptwrDuARJyD12fGVqiwXdrQ6EI8nlO0XZsbElCxWmlU15hhMBpgtxkLfMHIcrlMoAA8l2/ZejxmNLd4kM3mMDYaQjot4vCRMkxOhAtii0RREsRPToTR2xfE1MQ2+vorkc3yGB0JgaWoAtE6l+U0ACuTymlagowoKoyVvq2nd1+PRrVTg3Zdy5Bs8+nbi1tbaVQT7UQrERQtmZASnlLEdvEkB+Qd2bN5wJrL024cD3gc0vEpAnOwBgE//qcDyEbMSFAZWPNAyu02A/m3JEecVxaCpkXIpwQY8tsQHqdS7FH+ZZFM59R2I8GMpUUetvzjM2tRpaWYyBvXUhQQWZBAV0OvH729BxEKhbC+vo6JiQlYLBYFbLnd7oIvtqU0WPsM1uuv9gHWHi25NUdR1B2d2kskEhgcHITFYsHAwMANgziGYe6KVYMgCBgdHcXq6ip6enrgcrkUMXs6xeOPP/Eqxsa2UF1th8EIXL1SukVmsYo4c2oZySSn3FR5XhVwy0xPMf+q2ZkIZmciqKlxIBh0wOEw5CNhtDYOANA3EMQFwsqB1AUFKmxobnbDbGbx0ovFR/0BCfSsryWxQPg1VVXZUVvnRDSaxejIJvr6SoMenhextpZANstjciKMmloHnE4RiYSA+bmk4kHV1RXAtWshjYg8lxMUHRfLUrj/gRpwnIC2di/Gx7YK2J66OieyWV5htMgWowwuTWYpXLrY9CQA2O0GVNc48fxz0jWhaapgKvFghw+LCzEJZOgqmRQwPpbEkaMenDu7gZpaE9xuM0KhHJaXVHF7ebkFVptREzkUDqcVsMyyFN4k69S8ZiSThdotg4HC4SMBBcTJwwg2s3TTdTgMINt6evNPPQCjBNXgU9/WYw3ayT+9jorS/TFI13e9pYO+hCwH5GdXGJ1/FkPk85AQM52nuqJp6fcxwahgRYdLPbjRzOP03/UDAGiR8IuKZWHOAx670wjk3645AiAJEGEiwBZLiOwFgiaz2gxA/s9Dtg5pi8psccTAwdTlLThghOig0PJGH+x+E9ofKYfNZoPNZkNtbS04jsPW1hZCoRCuXbsGnufh9arslslk2m8R/hzVPsDarzsGsDY2NnDx4kXU1NSgtbX1pgTrd8OqIZfLYXh4GJlMBv39/TCbzQq4Wl1N4gPv+TGuXtlEfYMTuVwORhOD470BzM/FlDF+uY73BXDh3JoCLMibqsnMoLevEk6nEUM7+Dkd7PBhaSmu0Q5ZLCy6usvAsDSmJsNoa/Pi1MnS7IkoCFhdTWBqchs2uwGHj/hA09AERHf1VODqlQ1kdFqspaU4lpbiMBgoHO8NIpvj0XO8omjuoAx6ZGC3MK+uWXaTd7qMOHt6ueSEns3GorHJo2G/ZHuCXFbAyMgm6uvdWFmJKxYK+pqcCKO8zIoXfraA8nIrGprcyKQ5DTD1+S1wu02aKCBBEDVTiW94oBo8J4BlaYyOhApsHxhGMjuV/6YL8xkszEtr8vsNCFSYQdMMtkI5TRyOvrp7KvH8c/MKe1lX50RllQPRaAZjIyEYTQxaWjxFjUr5jADYAJHnNZN/FhMD0lqhwKmd+Hc6K2iicK73DstmtDmH5A2D1oEz/bubZLui8RzKCWbMala3NVvVk5HXI+uyQgkoAnaGVY+1tOBGZDwoHYc8MkeycRlY8/DMYGGA/Fs2CwEWjZUD4crOMsopJRIqg2V1GhSwFstmFVG8vG0OAux5btBRZcJ//c4xTQIERVGgaRo0TaO8vBzl5eUQRRHxeByhUAgrKysYGxuDzWYDRVGwWq2aIZ/dsmn4+te/ji984QtYXV3FkSNH8NWvfhW9vb0ln/+DH/wAf/iHf4jZ2Vm0tLTgc5/7HN761rfe9jr2Su0DrP3adTd3Mgy5o6MDwWDwpvchWzXcqZKZNavViv7+fo0z+6WLm/jAe3+MjfUkDh/xY2J8C6mUAKwB01PSp3RLqwf+MivWVmMoK7fjzA7O7HY7g8WFbSwvpxQ/J6/PgpVlNYD4eG8lLg6vFdzYUykOgxfWYDYz6DxUhnA4g4ETVVhajCm6HbmamtyIxdQ8wEQ8p9yoGYZCR6cfVVUOjI5sFoAruZxOI2pqnRqneaWlZzdgfjYKt9eMxfloUaYHkPRiLEvjuWfn8noxSfw9OxNRQpP9fgtcblNBFBBpT3C8twIcJ+LAAV9BO1A+p+4e1eF9fT2pRM/I/mI2O4vQZnpHnZqsyZLZL3UqkcbERBipVA7t7b6SLdvNzRzsdhO2tuLI5QS0tFlhNBqwMJdENKoC02LGrHNzUUW7V1VtR2OTB6lkDk6nseD6yh/WAqc1++SyvKYlaCU0V4KoFbnrLcuSKa21AsNoWSlax2CZSasFnXqe1m1LBjhzohZ+cQS7JRDHEPLb8/m+XYrQTVGU+ve/9tJB5WcLwyrIjCHAFmkTQRNoT9RK1GAi0CqfJsxQie1j0awC1pxWE5D/PmEXpb9KnMrBI0rMWX2rGyaTCYIgKDpO+Wdl33mw5XA44HA4UF9fj1wuh1AohOnpaWxsbODll1/Gs88+i5qaGkQikdvWYH3/+9/HY489hieeeAJ9fX14/PHH8eijj2JsbAzl5eUFzz958iTe/e534zOf+Qze/va347vf/S7e8Y53YHBwEJ2dnbe1lr1S+wBrjxbJJu0mW8TzPK5evYpQKITe3l64XDfnAUOu6U61COVYnqqqKrS1tYHneeRyOYiiiGeemsNHP/wsEgkOPb3luHB+HWKRZUzkXb/r6l2Yn4tiYCCIWDyLkWta9+4DB31YXo4poEHv51RdY8eBg34sL8dLek+VEs3X1DpRXe3A9nYaRhONyYltJIqIx6XjinA4jHjm6RkAQF29C8GgDeFwBmOjUnZgRaUNZhOr+GTJRbb0eo5XYDucRkdnGdbWY5ie1II8/ZRfNitoxN+NTW7U1jmQiOVwroSwHpBAz/lzWsPU5hYPysqt2FhPYHkpjpZWb8kInlSKQzyexdxsBOFwGq1tXvj8FqyvJTR2CCfuqyoQ55NTiS63CUePBUBRFBoaXUWnKDs6/ZidjSCRd+6eyE8lUhRQU2uC02WA02Hd0Tnf77fAZGTxcn7qlGVpHOzww+UyKQMUxw6VAUtCQdtOz1iJnOplxUEXU6if/NMBLv1rXS9UJwXy8XhOA870YGwnCwcjIdRPEvYjTpdB3hkAgDKqe7HntViJFIvRJzuk9UIES0z3mWkVbJHwLxLNwJwHSCmOU8xIs5QAIwHiSDaLBGt2ol3IxXgANJI0B6sg7Yf03zK3JDA1NQW/3w+n0wmKoiAIAkRRBM/zEARB+Q9QNacMw6CiogIbGxtwOp1wu9145pln8Jd/+ZdYXV3Fr//6r+Od73wn3vrWt+LYsWM3PZT05S9/GR/84AfxgQ98AADwxBNP4Mknn8S3v/1tfOxjHyt4/le+8hW85S1vwe/8zu8AAP7kT/4Ezz77LL72ta/hiSeeuKlj79XaB1j7tWteWOl0GkNDQwCAgYEBjXnorazpTjBYCwsLGB0dxYEDBxAMBhUxOwD82Zcu4M++eA4erwnHuvxYXYvAYmGQTBSuo6raDpZlFOAhG3vK7uqCIIBlGQwPrRU1GAUAlgUcDhrP5v2clKBmXrViqKt3IZvlNaBMOZf5KBbmJUf2qckwDh70azRfckneUz4NKzU3G1Eib7xeM44eK0c6zWNwsDToIcOlJ/MgxeszoaXFh2yGw+JiDOUB245TfmYTg6EL64hEMigrt6Kx0V0QGVRK8C5rzTxeM9rafDDmvbNGRwp1aoePlGFqcltxox8f2wLy1hOBChsaGpywO4x46YXS4vzycgtsdiNOEy1Z2bZCDsQ+dLgcV69sFv0biyKwtJiBx2PFqZPr8PlYVFSakeNoTE/FwOVV4sEqOyhAsdUAAI4TFNNRAHjwoVoYYxyAbIHtgh5gka25LA8Yd4iz0UN6Sd9FZA8aVECmd30vYUivFBHFV3Acq0XdL0WwXrF4BigD7A6JVRIIIObK5xA+/1IDhKQElnKUqAFIJNiymVhFsE4WqafK0QKMhM0DaUxqIPbLJfPXgGgFJkQVqB37z1X46BP9yOVy2NzcxObmJubn50FRFPx+P/x+P3w+H4xGCe7KjJYMvMgvk/JEt8vlwqc+9Sl86lOfgsfjwX/5L/8F586dwxe+8AWUl5djfHz8hkFWNpvFhQsX8PGPf1x5jKZpPPLIIzh16lTRbU6dOoXHHntM89ijjz6Kf/mXf7mhY+7XPsDaL+yOm/v29jaGhobg9/vR0dFx25YPu90iFAQBY2NjWF5eRnd3N9xut6K3ymQEPPbRn+Hf/3USTqcRfr8Jr7wsgQSyxTWTb1Md7PBhZTmBcLhQoCy7qw/cV4XB86toa/fBYmWVbeXyeM0oK7Ng5JrqgSUHNQPSNNPDj9RJ02PXsWGQ2SJ52s5kZnD0WDlMZhabGwlQFL1jzEttndQSTCa5/LYBmEy04slUaiIRALZCGZwJLSMQsMLjtcBgoNHXH8TkZLjAz6mrO4CrV9X25MZ6EhtES6+7pwxer0UTN6OvYNAOhqEwRJyP1Srp1FgDjcmJMJqaPBgeWtPEsWjXnERNjQM/fWauqEkpkHeSz/EFjNXKclwB0/e9oQrpNIfDR8sxORFGeEt7NzeaaHR0lClTm6EQh1BI2tZsptHQYIHdbsTWFoe52Z2MSoN46YV5BGgGv+z2FAIs3b9Jlkk/6cfx0KIkXcV12YPgBeX5PHRhzrptyWVkBC3AogpGH3nl7kMRIIplpL8Zw0h7T2UlWijH0XDaJLD8wk/U9lRW5DVWDKR43SCqYMlhV9t6mlcFq55IBrymXSj/LFIi7IJ0EeJUDt58K1AgrsUv/t/NoCgKRqMRwWAQwWAQgiAgEolgc3MTMzMzuHLlClwuF8rKyuD3+xW9FclupVIpxONxlJeXI5vNgqZpcBwHnufx/ve/H7/3e7+HbDaLsbGxm/qM3dzcBM/zBWalgUAAo6OjRbdZXV0t+vzV1dJfoPZLW/sAa4+WvkV4OwzW4uIiRkZG0NLSgrq6ul1xX99NBiuXy+HixYtIp9MKsybrrTY2UvjV9z2F4aE1VNc4kMtmMTGutr3IFhdFAQ8/UodMmkcqyWlia+SSDUbldtCli+vKti2tUsxKIpHF5kYK42PFDUYBoLHJgpdemAfHiaAooLUt766+HMfMTARmM4OOzrKioCeT5jE8tI76BicyaR4Opwkn7qsqcGYHCltx0rZrypo7D5WhosKqMFbF1+pGPJbVGIKSa15ejqOiwrZjDh8ogONEPPvMrOQv1u6Fx2fBKrHm5hY3tsMZBUjKlUxySkvvxH1V2NpKoae3UrOtXLKwXm636k1K29u9qKyyY3MjVaAPI2vgRBVeJdzZ5alEg4FDKJRBPCagptalCXMmK50WIIoGTIzHkUhyqKk1weUyIRLhsTCvxrCQui35w1qfB2gyqMCHF7VtPT1jldVNWVosWhsG/TuXZMf0lg4WKwtSzCRF8kj/zuoAlr79bSHWTH5cWM3SYyIvsVVsPvA5FDMiQCUQCpuxePUgZPstnhKVJWUhaBgoMaM6qqbjOVjzW7mI6cJkllMsF7KUAFMelAkQYcyDtShycOUbrRZC7E4yXK1v9ENfNE3D4/HA4/GgpaUFqVRKYbempqZgNBoVdsvrlTJFr1y5Ar/fj0AgAFEUIYoiJiYm8tdQ+ow2Go04dOhQwfH267VX+wBrv26ZwSJZoWPHjsHvL/yQudXaLQ1WMpnEhQsXYLFY0NfXB5qmFXA1ci2M33nsZ7DZjOg/UYkrl9YRj5e+DgMDVZo4GsnWwIVINIPRa5twe8woL7cVNe2U/Y1MJgbzc1E4HEYMnAgiGs1i5NomyFMdOBHUTAqKotZdvf2ADxWVNmysJ8EwVFFrgs5DZZibjSAWy2JlJaFsW1VlR02dE7FIBi63uUB/RJbHa0Y2yyvu7H6/ERWVZoiiEaMjktasVO4gueaBE1WYm4ugr68SsXgOoyObmoBor09yeL84vK5sS9ocVAbt6Oj0I7yV3nFCb+BEoZ5Kaum5kEhksbYah8ttLgmcBEGEwcjg7OkVJBK5gnagHHNEsobktnIb1+s1o6nZA5OZxeEjZUUjkg4dLsPUpOqDtTCfwUK+NefxsqisNMHltuA84afG5pEIqzMapXnVhoHTASxp0k99TevxbSKZ00bhOHS+VwRISmUFeIiufzLBabY1kBE813nrGgixl8WsHsSeB1g2k3RdLCY1hzAA4PS5dmxHeATytBpjpJSOJk+LyqnyEDV6KtJkNJXkYMlfMI2VA8FtcUYRxqx0ITPE4/FoFhaYIUJE+8NlaKxzw99ku6EvlRaLBTU1NaipqQHP8wiHw9jc3MTY2BjS6TRomobNZkNdXZ3SSlxbW8P73/9+9PT03FZUjt/vB8MwSraqXGtra6ioqCi6TUVFxU09f78Kax9g7dctsUXZbBYXL15ULA5222V4Nxisra0tDA0NIRgMoq2tDYIgKGL2Z5+Zx0f+f88imcih53g5hgbXYbOx6O2rRC4nYOTaphIpI7NFel2QbGsAAAc7/HC7TUinOJgtDNJFcgP7+isxeEFqXUWjWWVbl9uE1lYveEGA0UDvaMNQVm5AKBRXMvZUzZeI0ZFNJBIcevsqMTRYvEW2tBTHxkYSh49I2qGe4xUQAYyNhDTu6jU1DgiCqGGlNjez2NyUbr5OpxF9A0FEtzMaDQ1Ziht9/rrJbvVyQDQAhMMpZNICJsZLs3nV1Q68+Pw8cjkB9vy2NICxsS1Eo1mwLIVjXRVF2Ty5pRcM2uFym+FwmnC8txIT41vY1lk/dB+vwOWL68okJ9kOtNkNOHLUB6/XjLMlpgkBaVDAYGA0Xl02mwGHDnuVqcSGRjeuXFovmBiVK7Itae9OvboJs5lGXb0FZrMBhiXp77NjS1DQa5+0N349wHLqwpzJ/ECg2CSgugP9Xz1LGJxSOmBnsTIgm3NGYo18Tn3dGal8/qBT2rs93xZMZiRA9NKPWjUsaCarHoPUVnGMAANP6KnI1iFDK8RbNKrmEJpsrCJkj/E5xUCUPFNrnuFiHQw+9u8P4laLYRiFvcpkMjh//jwYhgHDMPjOd76Dr33ta+jv78fZs2fR19eH7373uwXeWDdTRqMR3d3deO655/COd7wDgPQF+bnnnsOHP/zhotsMDAzgueeew2/+5m8qjz377LMYGBi45XXstdoHWHu0bqdFGIvFMDQ0BLvdjv7+frDs7r+MbleDJbct29vbUVVVBZ7nwXEcKIrCE9+4iM98ShJ2dveU4fw56WYYjXLKVJrZLEXKmMwSWCrmSyTXocNlmJ2J4NpV6eag6pgYRYu0k1N5ZDuDyckwAgEbrk5v40jeqXxqIqxphx3s8GNxIYpoVL0hypovQNJtPfIL9YjFs/B4TAW2BoB0Q62ucSosm/x/WWtmtRqQyfKYmd45bLnjUJkizjcYaBw6JNk4zOZz+Ox2Axoa3UWtDeSA6NZWL6LRHALlVtTUOjE3FymIDCKF9YCkEbpAhEsfPVYOf5kVoyOb+sMo1dTkRjSa1YA42Yne5TZhaSGGYJV9xxYmzwngeRHPPD0LmqZw4KAPbrcZS4tRzOc9wOrqXUincljQ2WeQbci+gSCikQy6eyqxulrYwpRNRuXXWzotYHJC0qkdMBgAJ2Ak7BAEHWOl11wlUjzKCB8ruy4KJ6YLc9ZLpVgit9CkayfqixTXJ9K8JoKHJtxQswJgJwCWhUCETpm5YqQ1el0SEjJaLdiOGTFzphmg+KL+phY7q7BRGYFXWCoAGm0WnybicAgAGk9kYcuDLdZIK2aishYrAx62PHPm8hIZQbdRuVwOQ0NDcDgc6OzsBE3TaG5uBsMw+JM/+RNkMhn85Cc/wX/+z/8Zb33rW/G2t73tlhmkxx57DO973/vQ09OD3t5ePP7440gkEspU4Xvf+15UVVXhM5/5DADgox/9KB588EF86Utfwtve9jZ873vfw/nz5/FXf/VXu3Lue6H2AdZ+gWVZZDKlb6Zkra+v4+LFi6ivr0dzc/Ou6K2K1a0yWKIoYmxsDEtLS+jq6oLH41FEohwn4stfOIt//OE4rFYWtXV2XDhfvF2UTnOIRjKIL+ewsZ7Mj8wbsbAQxeKCCgL6+oO4cH5VozEhdUwWC4sHHqhBjhNQW+ss8K4CJLNJOcQZAC4Oqbot2TOLoYGzZ1ZKsh4MAzQ0WvDTZ2eVbVWvLsmpPBi0w2CgNdNpcslas67uAEauSmHLzc1OLC1FsLKs3lRpGjjep83yy+UEXCZMPI8eK4fbY8bSYmnh9pGj5ZgY30IyySlCd0CKDKqstGFrKwWv11KUlZLL7jAgmeTw02dmlesYrHIgsp3G6GgIggAc7PRjYS6qZBPKxfOich0GTlRhcSGKvv5KRKJZjOpatg6HQaOnEgRR46sVCJjReSiAaDSLoZ2mMIv4YJFtyNmZbdQ3uEuCedk2gNRg6W0YrjclGIlmUUNG4di1oIkEWHo9VzSRQ4Agqj0eM8CrIJ7Ua+nZrmScA9z5/VJaCs7A5ONxBBEeo4AMD7hMPHhBhMsi6Ry3ozlMnWyCyLNw2RlFsK7xqoqpAImMySkQr1O0sjRyJTa7Qdmv7IfFQ4RDlECVaKPAGhiwAoWOt91+myyXyynyBRlcAdKX33/4h3/AAw88gB/84Ae4du0annzySfz1X/814vE4PvrRj97S8d71rndhY2MDn/jEJ7C6uoqjR4/iqaeeUlqP8/PzGuH8iRMn8N3vfhd/8Ad/gP/xP/4HWlpa8C//8i/7Hlg3UZQoFosh3a+f9xJFEdn8hM7s7CzC4TCOHTu24/Onp6cxPT2Nzs5OVFZW3tH1jY+PI5fLoaOj44a34TgOFy9eRDKZRFdXFywWi6K32g5n8GsfeApnz6ygMmiD28WAonmkUgxmpgtBz9GuAMZHQwVZcYAKAixWg0aTpS+f3wKfz6Jps9XWOVFV5UB4K4WxsS0c7PBjYQfTTkC9MVdXO1BT60AkksHoSEgBAbI5qN6/iqzjfZUwGmlEtiXNVzHd1sCJIM6cLmRxAhU21De4kErlYGBoXLhQesqvrt6FTIbDaj7/r6zMisYmNzIZ1V29t09qlZby/ZJbi9PT22hqckst25FNTdu1MmgHy9IFbJFcHo8ZPb0V2N5O4+rlzaJ/R4qSAPJpnUms0nYVRWysJZVg7FJ16HAZpqckSwi5/UlBG4i9E4MJSH/D+gY3DAYaDENhoshU4lsbvHhrlEJjo7reOAfYia/JYTDwEK25iQSFFpv697wap9FhV6/7lRiFTof6+5UcjUpD3uSTByxEV2osTqHNLpbcNs4D9vzzp5IUmqzq70biQIdL2m8oC1Ta1bZgzMIhaE5iKyuiqSGEzQyNpgOr2EwxqDwofdl4ZcKHn/x7N8aeP4IUcvDlJ/l4uwhzXAIFm1QaFYJF+blclARjSYaDlVcvEg9RySVMGDnYstLvwnQGHkHabxYCjKARobJwiRKE9dxvwx8+9TB2oziOw+DgIAwGA44cOaIAm1gshne84x1wuVz413/9V5hMWqaMdHffr9d+7TNY+3VdJ3eO43DlyhVsb2+jr68PTqez5HN3qxiGQTpdxMSmRCWTSQwODsJkMqG/v18jZp+eiuK9v/IjzM9F0dbuwcpKDCvL6vlWVtpQV+9GPJbByEgIx/sqcbYI0JBrfS0Bj8eMUyeXUVZuRVOTu0AI3dDgQjrNacAVAMzPRTGfd+6+/4FqZLMCGpvcRTMHFQ1TnvVYXIxhcVH6iu32SLotigLC4cyO4Kqx2YJLw2vK/p1OI9rafRBEEaPXJPDRPxAsqf1aW5UyB8vKrJhejqC7pwI0TWFsNKQBhgc7fFhajCugApBy9OQsPauVxS+8uRaRSBYOp7EAQADSlF9Tk0dpLYY01hOSfUQymcPqSlLRRxWr1nYvnnt2DoIgqlYbFgNmZ7axtpZUWnF6cAWobddglR0GlobFYlCE+voWZldPhUZPJbc/AcI9v9qO0WuFPmZyyVE+8sQpkJ9oPOCDx2PG6kocNrsBkdkkOKPWW07PWCVS2tYca9TG2ZgtLHaaGiT1XIJuarAgp1C3LXkzMZppkBosMi9RT8IKuRxgBrJMPnYmrzXK0Co3JwCYPt0mrZF0aCdIbpfdBETl5xPrJqwYchBgJHOGsurzHLQREIA4corXVYY4h6PduyPulsEVy7IacJVIJPDOd74TNpsN//zP/1wArgDsg6vXWe0DrD1aN6rBSqVSyofBwMBA0Tf9naib0WCFw2EMDQ2hoqIC7e3tEEVREbO/9OISfv2DTyMWy6KrpxyXL24UTHStrCSwspIAy1Lo6w8ilxOkoGWdYScABAJW2B1GpV1EejnZHUYcPuKFzWHA2MiWEgtTrAZOVOHllxaVfyteTiyN8bEtCIKImlpnyXiW7XAG4XAaW1tpxOPZAu8qufoHggXaomg0q+zXbjfgwQdrkc5wKA9Ysa7LWAQkt3mIlAIW5RYWy9Lo6PTD6TSCpoDz50ubqlIUcPhIOZ7Nt/NIACE7lfv8Fng8ZlwqMuUnt107OiXGr6LSjpZWjxLUrLm2ulac3k3+YIcPlUG7AnSLVWOTG9FIpgBQVdfY4HCI4HIGeP1WnDuzWhKIU5TUIn7mKemcJed9ez5MW5rCrKi0wcAWMmTS0ILUhjzWVY6trTQO1zghbmqZTj3A0rfmUmle43uVSmnd1/WyaVoQlAfTnKjJLZRQkrpvvV6LjNGJJwXNcQxE/5BiGZD2DmZWQlzxrBz0LP0/Lag7XFj0IJeSwKWR8LfiUwLkRl8yloMlL0x3OIwK2EpnOSVTMKsDWGaKBUQgBQ4WTnoObacVsTsJIw/9h9sHWDzPY2hoCAzDaMBVKpXCu971LjAMg3/7t3+DxWK5zp726/VQ+wBrDxdFURBFsaTeaWtrC8PDwwgEAjhw4MBtm4feTN2oTcPS0hKuXbuG1tZWZfxZzv/6zl9fxec/dwatrR44nDTOn10rAFdyOZ1G1Na5NGP+imGnicXExBa8XgsikUzJdlE8lgXL0jj58pIEKA7LGXzbSji00Ujj8NHyAm0R6eVUXeNAZaXUAgtW2Qtu8oB00x0b3VJaX6R3VXu7Fx6vGWYzi+d/Nl/y2tnsNHx+Fi+8oD6nusaM6moPNjZSmJrcRlu7F+tryaKeXxwn4OqVTcm24NQyauucCFbasRlKaZg7k4lGR2eZhi0iAQQgtWSdTiM2N5KgaaDYn76rpwJXL28gk+ERjaq2FRID6UI8noXDYdoxksbjNSOXE/Bc3npCdpMnW5gHD/qwuBgr2rZdXJBA88CJKoyNhdDdU6Fx3pfLbGHQ1ubTWHbIzvuA1IY81hUAzwuKPUWxOt4rTYRynIAaUxbHHLqWkZ5l0m1/Pf2HnhAhbwj6t4rNbtAI5EktWFbQTgbqMScZoyPQ2oOa8uaiufxzjHYJEW7F1eu5OlcPQIrGIQXrJFgima1sWjUgNVlZIP9dJ0cJykXhGDVmJ0FxsORzBWMJNXfw0NsDeOPb6mF1GVDX68HtFM/zGB4eBkVROHr0qDIVmMlk8O53vxuZTAZPP/00rFbrdfa0X6+X2gdY+1XUB0uOlGlra0Ntbe1dX9P1RO6iKGJ8fBwLCws4duwYvF6vImYXBOATv/8K/td3rsBsZpDL5fDi81tgWAqdh8pgtxswM62CnpoaB0BRuHJZy5zIhp0A0N0dQDrDo6nZA7OJwcJCTPNcikJBm01mYmTBeaDCBlEAXn1l8f/P3p/GR3bQV97499a+74tUWltqrb13qxe1g43tBLMYuw38J8wwJBBCNiBDQkIywCRhQljCMzB5wod8IA9JCAxhAG/YBuPd3d573yR1t1pLa9+rJJVqr/t/ceveurcW2WAbMK7zqrtUunVrke7R+Z3fOVRDV7ePhYUNjXK1pc1NXZ2DxcUNrlxeqahKFV8XGB2NYneEePaZazQ1OWlschGLSYXH8nUu0iAloo+PaZ/H5ESSyQnpsX/tDY2FEZuetbWUJrtKxqHDxYT3sdGYklMVCFhp3+olk8mSyYgKeayEzk4f18ZiLBdGhpUqgzZ7zjMzcZaWEuzYGeL8+QX27a9DJ5SPMOsjDgx6QbNNWJomf/ObmthYzzI3X67kyVDnYC0vFTc4d+0OYbUamJ1Zx2ozbkqcgiEp92tlJalRAtVLFAcPRXjh+WnlPTMI2igCkHOuikSk1FpnKPl6adegxaQlaJpi6JL7xmLajUOLpRjFkBa1ZvtSoqcmY/FETil6BrAaChuRhf7B1XWJxKlabzj7VJP0OOQV4pTTixhVNTdqZUuvYo4bGxmchUudYBAU8SwuFANE1a+rEiAqwEe/cViKb3iZyOVynD17lnw+z549exRylU6n+a//9b8Si8V46KGHcDgcL3KkGl5LqBGsGjQjwnw+z9DQEDMzM+zbtw+fz/cLO6dqBCubzXLu3DnW19c5dOgQNptN8Vutrqb5ww8+zLGjEwQCVuwOHefPSWpKLitqSNTWDi/NLS7m5+JcOF/dw1QaFQDQ0uqiIeJkYTHB5ESM7p5AVQ+TKEIykWVsJMbk5FpZQKms1uzdF2bg4hLJpHYsOToSY3QkhiDAG25oIpPOsX1HoGKApcdjpj7iUMZ4ExNrChn0+Sxs7fBiNOoYuRplooIyJqO7x8YzT08q56bOrro0JJ3jrt1hTU+fGouLCfQGHRaLgYX5OHv3hTEY9Fy5sqzxXu3cHWL48rJG/SmtDJKjJwIBS8XoCYfDqNm+U8c4yMQlsZFhairOzHR14rR9R5AnH5sgm81rlMDx8RWmp6TKoL4D9ZXT81M5zp6ZV/xU6VSO/usaWFzYKMv46t3m59q1NSWcVVYCZbS0uOjq9jE5uYYgUCRYCJpuPpDIil/tuTJqvU9lRqmS/5tVXYNQkr7+IrlX+XSx7qbUr1V6Z6vKk6Umgek8OAuP6fNLZEeUn2NB2bo67WR1zosBMFh1UHgLk7kcloKaJaqS10FOcZefcvFJp7LF1yYtqnK6TAYlDsxZmKmarPpXhFzl83nOnTtHNptl7969SqxNJpPhfe97HzMzMzz66KO43e6X/Vg1/HKhRrBex5BHhLKClU6nOXPmDJlMhv7+/l+oVF3NgyV7woxGo5LBJZOr8fE1Pv+Z55idXWfrVg9Ly3HGxzIVji7B57Ny7MkJMpk8jY1OGpudrMZSitJjMAjs66scYDk+tsr42CrBoJXOLj9ms56du4IMXFwsU3p6tweYmlwjVgi2VAeUymZ1l8vEM09PlZErGRaLnt5tAY49WSwndjhN7NwtGd0vDS7hcpvR6XSaCAE1lpeTpDN5zp9bQBRh+04fmXSS2dkssWhR6SlNkgetedvrtXDgUJhcNk+4zl7Ra9bW7mFtLa0USqvraKQMKTM6vY7nn52uuk2o00mRD3L0BEikOBi0MT8f5+pwVPFtlaqPUCQu8sjP67PQ39HAykqSS0NLGsLcf1jaJpRvK02Tb25x0tHpY252A4NBqKjm1Rd6EuUR8tWCN0y9SakTBAYGykm0Gg0NTh4qKQDPiyK2y+sa8zaUK1bJVF4jJZlKTO6lfCuTzCrhoKWxDIYSdWuzGp1ERsSlml7a7Nr4B12u6O1Si5Bqy97qagI84HAVUtad0gM8c7oRQ+Gb44kMTrl7UDXuk5St4uXMqjcoPFMd5aCOYhDyxduNqYLB3iLiCJix6w1svd7Py4VMrtLptIZcZbNZPvjBDzIyMsLjjz+O1/vyxo81/HKiRrBqUPxOzzzzDG63W/OL4Bd9TmpEo1FOnTpFKBSit7cXURRJpVIIgsDzz83ywff/mGg0xe49QaanYzQ0WIlE3IqhWI3SuhP1hp7PZ6FnWwCzWcfTx6qP89rbPayvpzWjIFnpkdPRe3oDnD0zVzW/ajWWQqcTeOThcSXc1GjUadb0fX4LwaCtbMymDt3s3ebHYjFgMulJp7LK+FONQ/0Rjr9Q7B28UFD2ZNLj9VowGgWefKL6c/Z49FisouZ1ad/qIRS2szAXZ3g4yvYdAcbGVsvqc6CYIdV/uIGnj00WjN9SdtXgYJH0WCx6enoDPP+c1uQ/fGWF4SuSIrR9RwCfz0J0JYXRKFT01+3eE2JocFnKNVtNMz4meaBkNS+byWOzG3jqWHXflt1uwOWyKL4tJYpBNYZsaXWT2MhUVMjkTcq+/XVcGlqmp9ePyaSvWIh9qD+iiXNQq3kNDjtmq9aWXjoxLf2Ura1px3pupza5XU2o0nltLAN6bfq63a7tHjSpfkWUbTPGtRU86u5B9V2TKpJjLpjdM+nC+RX8XsOjHcp9RFX3YNmmoOpvKYNqvui0Goqq10bR8G4reK4SZLEWbnM2mfnsmVt4JZDP5zl//jzJZJJ9+/ZhNErKWC6X4w//8A+5ePEijz/+OH7/yydyNfxyokawamBpSVI8IpEIHR0dvxSrwKUjwunpaS5evEhHR4fGzA7wH/9nkE/8xVGy2Tz7D4Q4cXweUYT5OekCL+ca5XJ5RkejbNni2TTA0mozMHFNilOw2Qzs6wuVxRLs3hPiyuUV6UKiglrpOfxrDayvpdmzt46rwytlJcV2u4GtHT7F/J1MZpXtRJ1OoHebn2DQRjSa2tTPU2m0uLXDSzBkY342ztWr0Yr9eTLyeZHJiVX0eh0Xzi8opKdU6Wnd4mJjI1tGIq4ORxXV5vobGslkRNra3BVHmFL2VPFc1MZvmfTk83nSabFqUTJIpG5mpjjalTc41e/TZnlby8tJThyfYf+Beo4fn1X8U1eHV1hYKL5PHq+ZYNCmUcjU77HBoOOGNzaTF/OMjkSrnq/aQyY/L7kQ2++3Mj+/js9nqxgbIcNu1pMrYVRWu5YwlRYwl2K9pApHSlEvEJsSgrUez2ruW9o9aFZdPTL5zdUuvWo70e40IatbehVLs5pyhXOSPscOW4Z0Vsfpk42KKOdwmCpHMehUhnvyyugQILORV4JG3QYz5KT4BVvh8qc2uLdtfWWUpHw+z4ULF9jY2NCQq3w+z0c+8hFOnDjBE088QSgUekUer4ZfTtQI1usYclP72NgYAM3Nzb8U5AqKI0JRFBkeHmZ8fJzdu3fj9/sVM7sowhc++zxf/crpQmaUn+MvlBMROdcoGLRSX+8gn4cDByNcvrxUVgfTu83P9PS6cvvGRlYTS7B9e4C6iIOLFxbKyJUMOb/qmaeKhEZ9MZ2aWiOZyOB0masSJ9nMfeb0PLFYitYtbiL1DhYWE1y5XBxd9R9u4PnnpsvM37LSYzLpuO7XGsjnRLbvCDBwcbFsQy8ctmG3mxQSoSE9fon0mE16BgeXWFwo90DJ6O61cezopELI5BGmbDhPJrPs2BniuWcrE73l5STjYzGsViMzs+tSZZBZz9XhqIacbtseYHxcq5Ctr6U179PNv9HKRjxDuM5WMVHeZNKxfUdQUcjk90EQoLHRgs9vQRQNrMbSm/Ykdvf4OHF8RvkstLS6iUQcRKNJhgqKXDVyKxdim0zSluXExCqH+iNlmWoghb2aRR3JjPbzurqeJqKOXdBrN31Lf5pdJcntZIojxdL+wLLcq5KDCTmUK4jJoh1FlibEq71da2spKIg2adWDOAoEy1PoH/Q40wyO17O0JCDHGsfX0jgLM02rWpnKZHEXvFNpchqCZS1EMaTJYyqMAtNmEXPhpcyrVLGON758NUkURQYGBlhfX6evr08pbhZFkT/90z/l2LFjHD169FUPa67hF48awXod4+LFiywsLHDo0CGeffbZn6qP8NWGbLw/c+YMq6uripk9k8mQz+fZ2MjyoT94hKeOTXCovx7IcOF89TDHrR0eVmNpBi4uqR5D6qNzuUyMj6/S2OjcdJyXz+dxOM1KNYtcRTM7U+yUc7vNNDQ6y/Kr5IspSOqL3W7D4zFjNOrL/EAAfQfqOH92QcmVUm/oSeGmbpxOE088fq1qDpPcO/i0iujZ7Xq6ewKICAwNLBKus7MRzzBSRX1ZXkqSaxN54fkZdDqhMMLUl5HTQ4cjZYZ39QjT4zGz/2CEXC5PXb1dSXpXo6VVCmcdK/i21JVBnV0+AgErgiBw4vhM1bwtkKINHlX5tlpaXUQiTlZWElwaWsZmM7ClzVtxs1EUYXIyiaAzkk5nlO3QjXiGwUEt6dm7N8zFi4uacxkfiym+M5/PQl9fPYtLG9hshopp8labga1bvYqqJb8uckG0Xq8jFkuwupohuZZBdGrf69LPTaykW7DUg5WMp0FVd6PeGtxI53Gq/Vtm7feWpCtoSNP6Rk6jdpHPKz00qdLRowrryeJr57HmAJGwOw2I+Jwp/u8DYQ1J1Kv+J6rG/gajThHycnpR4Yl5nYg+L0cxZDDL6e7p4mZhx81B3vsXO7F5jAS2vrwtPplcxWKxMnL18Y9/nJ/85CccPXqUhoaGl/U4Nbw2UCNYr2O0tLSwdetWTCZTxaiGXyRkspdOp+nv78dgMCjkanoqzvve+yOGBpdoaXVxdXiZhYVUYawmdQaOj60yXUj63rs3zFCF2ht1H93hww3MzcfZt79eGaupYbMZ6OzyadSXK5dXFHWjocFBR5ePdCq36fhx1+4Qw1e0o0Wf30JHh5dkKsfQwCJ799VpDNelWFtNkU7nefihcRxOE7t2+6BgdF9bk45bV2/HYjaU9Q7G4zlOnphTzkWvFwiH7eRyYtkIE8rN36UjTI/HgtGk58nHq+dtud16rDY0vq22dg/hOjsL8xsMX1mhu8fPzMy6sgighkxOvb4Ix5+fpr7eTnOLSxPYCRJhrrSUIC8kgJSwL3+vxarX1O/I6Oj0sriQULK/FNLjMLJzlx+dDgwGPS88P12xcgiKpPChh0YBlCUIm60YEeJymYg0ODlfIVhVLoje0uZmfT1DIGCl3qLHlNeqcS+WFJfNaCMRSkmSOrtKZ9BuICaSOY1h3mLWfl2Te1XyuKlkkXDlSqQvt9uEPMaUX75MXsRrzLGa1tFkyLGaNeLXiVwdbsdk0ClTT4NKmRJEVe5VpngG6siFhCGnVOFk1CGpKqL2wc/sI7L95bdTiKLI4OAg0WiUffv2KaHMoijyqU99invvvZejR4/S0tLysh+rhtcGagTrdQyXy6WQqs3S3H/eiMVinDx5EkDJjJE3BU+fWuAD7/sRiwsJtu8McPXKMomE9Ms1nxc1hKKt3cPWDi8jV6MV1QOQQjB37AwpxmLZSxRpcNDS4iYWS7K0lMDhMCmZWJXgdps5c3qO6EpK8hJ1ekmncwxeLFbgHOyPcEJlMpexvJTk+aUZ9HqBAwcjpNJZxRBdGnbp9VkIhYqG93WVH8ho1LFzZxCPT6pXuXyp+mhr/4F6jVqnHmFOT68zPhZ7Ud/WtfFVdDrJt6V0LK4kGBpUbd81u0hncsxMaxWrkatRJYH9ul9rIJ+XxnaD8XLfFmjT2dVbmG63mY5Ob2F8JfDC85WT70Eas+XyIk8+IW1iWiwGdu8JodOJDF9ZZnU1x7btAcbGYsTXy8e/8fUMJ0/M0n84wonjM3R1+3G7zUxMxDQF4AaDwO492hqeVCqnSZPfvSeE12spy1NTo7PLx9xcnFg0xcL8BgcdDpxO7efYUWJaL0XpiNBsqB7LsJHKKxuFUB7LIKiU0lRe+72lPFOvipNIZERNX2IqkYFC4bRM19ZzEAJieYEmYCkuYEnqGToTVoto2PQG5f+iquZGPRjNqs4znskq24V2q1EZKcoGd0HHK0auhoaGWF5epq+vD4ulyGr/9m//lu9+97scPXqUtra2l/1YNbx2UCNYr2Oo/Va/LArWzMwMFy5coL29ncuXL5PNZsnn84iiyL13D/O97w7hcpnZssXFyRNzFRO/QbrIBYJWHnpQUhAiDQ5JuVDFMPj8FkJBmyZtW8b01DrTU+ts7fBgt5vw+624XCYGLpZ3Bu4/UM+5s/PKqGh5OckLBW+PXIHjD1h54blyciXD4TDS1q413xsMOk0wqsmkRxTh0lDlUWgmkwedwMnjs8TjGdraXZjNWdbWYHKiaEyvlOulHmGaTDque0Mj+ZxI7za/JqBURjBoxekyK74tdceiP2Bl61YPBqOO4csrFTcaZXR1W3n2mSnlfSyqRJJva20tzcFDkarp7LFYisuXlmlodHJ1eIUdO4PY7dogWUDZ8lPX4ySTWYU0CwLceFML6XSOUDDD6Hqs4uOpSaeazLe0uIg0OInFkpjM+oqfKRnhOjtLiwnlsUMhG1vaPSQTWYYGC2ny2wOMlxA9AwKU5GBtbGRhkzQVp7PEc6X6gSlNX6/y0VQg5rTfqyZYpURPvZ1YypdzqqUDU6FfJ17Y+ssWzODxnI7jA3XkswaM6iBU1a8ou9GgKFt6lZrlUEcxqB94QzpOziDiabDgs1up3+bc7Cm/JMihx4uLi2Xk6vOf/zz/8i//wpNPPklHR8cmR6nhVxE1glUD8OLJ6a82RFHk6tWrjI6OsmvXLvx+P5cvXyaRSGCz2fji54/zj/9wEr1eYNceP6Mjy+zc7SOVFBQzsQy320xjk1MhOVAkTCB5Y3btCZFO5zn+fPWtrT17w1wqjBZltUUmTHq9jktDS2zbHtx0JJjPiwiCwMM/GdMSptGYkh8VDtuwO0wahQOkHCeZwPT0SqTD5TZjMuvL+vcADh6q5+SJ4tbcyNUimWhocNDc6sJmM/L4o+NVx48ul4mmZpdmnCdv92UyeQYHFgmH7aTSuYrnAFJBc1OTU3k+UsiojsuXlzW+rdLOQCiqRCCZmK+/oYlUKkck4lBGvmoEAlZcLrOS/aUet0mZWVayuTxXLq+ULTSosf9AhKNPXlMIcEODg6YWF2uqMaSU1F/5vR4fX2VpKUFzi5vx0VUOHKwnmy2v0GlqcpLO5DXK1fz8BvPzxULsm3+jmY14BrNZryVYQjnBypRsSNpL8qc21rXdg+rsqiza9PXSYuhSqL83U/KHTTKVA/NLu696TJlMFB7PIt24npL+n8wJnBqUfEqmQrJ6ThDRq/oJhYw6isGkqFOJjQyOwtagtZDurs7JMocMfO7im1+RhR55UWhubo6+vj5Nh+CXvvQlvvrVr/L444/T09Pzsh+rhtceagSrBuAXOyLM5XKcP3+eaDTKoUOHsNvtZDIZvF4vTz/9At/4+gLPPLWE02UkErFx6oSkHCwuSoqLpJh4payjWKosGbsUjU1Ojr8wy/paumAmDiHoBC4NLioepmrbeXJnoNEosHdfPWtraQ71R8oUEyjmV8mEQU2YALZu9dLULMUhbDZ+3NdXx4ULC5KvpQBlhLma4tLgEgcOVr/4AywtJQiF7Tz79DRer4WOzgJhGlxUfEjhsA2rzVj22i0vJ5XR245dQcwmPTq9QCqV06Syyzh4SBqhyWRFHmcqSwVuExaznicenyj7XhkWi0C4zqiM8wDa2jyK+nP58jJNTU6yObGqQX/4ygo2m4HhKys4XWYO9fsrmtUrjULVY0ivz8yevXXEYimcTqPyGVFDjnOQVS359ZIrdCwWAxsbGaam1lheKn/NZHT3Bjj6xDUymbymEHtmZg3DImUEqxSJkvwpl0Mb26AmPjkqFEOryJjbbQQxXfF7S1WpVAnBslsMyGTNZDWiVrcMqkgFWXjKFv6RF6TPotlh4MpQC3lETIXLVE6XhwLBypDHpuohzG7klY5Cl8kECek+diWKoWhwb2xyvWLk6urVq8zMzNDX16cJZv7KV77Cl770JR599FF27Njxsh+rhtcmagTrdYxfhhFhMpnk9OnTCIJAf38/RqNRMbPX13Xwyb94gLNnlggETQiCyKWh8tHN0mKCpcUE23cESKZyNDQ4CNfZGRxYJB7XksbSsM14vKiYGI06du0OEa6zcfrk3KbbeU3NLp5/Tqt+dXRKKePT02uIeUldqDbOA2kc9sLz0oq/rJioR5hQbjKXIStyBoPAwUMRMpk8e/aGGbg4TyqlvbPHa6YubFcM6isrRcIk+ZDCOBwGZmbiVYusoXxrTja6u90WJidWmZhY29S3lctJXqcdO0M898w0rYVIg6XlhOZ1kutmSs9lZCSqkKm9+8JYrAbi6xmWFjcqbn727a/j7Jl5Mhlp61RWDG02Pa1bzDidDmx2E08drR6sarHoaWlx89gjUsio0ahjx44gdoeRsbEYszNxwmEbFquxYpyDXKHT3eNjZjpOMGSjq9vP/Fz5a33gYISTJ4qfzdJCbFvAh9dnRpFqKkCv15Km5EZGM0K0qAI/U1lRszVYOiKMr2c0G4d2izYzazPk01mFcGVyIioupCFqhsLt8ZREAg2FGWB0NcfYUJi8TkQojA/T+RwUohgy5FEf1CLoQZQM7saEdP+kMYczI90/qxcVca61/5Wp/xoZGWFqaoq+vj7s9uIL9fWvf53PfvazPPzww+zZs+cVeazN8LnPfY677rqLoaEhrFYrhw8f5gtf+AJdXV3KfZLJJB/72Mf47ne/SyqV4pZbbuGrX/0q4XD4VT+/1zNqBKsG4BczIlxdXeXkyZP4/X62b9+OKIqKmf3ihSXe919/RDKZ5aabm5ibj3L5UvXuvAMH6zl9ao5MJs9MYZRkNusLWUoGhoeX6ez0b6rymM16RFHkoQfHEASpeNnnszJ17EXDAAC4cUlEQVQ1uca1Qi5UpMGBwaCrqJDJW4XbtgdIp3NEGhy4XOaKMQylRE+tmPh8Fjq6vLhcZo4+ca3qOM/hMLKlzcMzqjGbySSwa3cQs9nA5cvL2O1GdIKgqX1RI5nMksnkOHtG2myUCVOpcftgf4TjJWXL0lKBRAAEAW54YxOZdJ6ubl9FYul0GmlucSuEdmwspkQyyOXQophnbm5jU6LX0mphcGCRREF5k1VInU7g8qVlYrHUpuXQGxs5hq9scOCgh+eemVb6CsfHV5Uxsvz6Nre4NepiJpPnvEqF3H+gDqvNqHzmKmHHziBXh1fY2MgSi6WUJPq6ejutrW42NjI4HEaefab65qgggNWkJxpNguqa6HKVBI1atOnr+hKhxqDepDMVVSYoN7WXrgaKmbzMb7A6TJArqlulepDa2xVPaLcRXfZi3pbFKt1RKKhaNqt0PlOzLvI5A6IxX3TCq/z5+ZIoBlOh9HldyOAVpQdLZHNKr2Bzv5c/+vx+bB4TrgbVWuXPiNHRUSYmJsrI1b/927/xV3/1Vzz44IPs37//ZT/OS8GTTz7Jhz70Ifbv3082m+UTn/gEb3rTmxgYGFDO7U/+5E944IEH+P73v4/b7ebDH/4w73jHO3j66ad/Luf4eoUgitV+pGv4VUc+nyeTkf5yHBgYQK/Xa/7qeTUxOzvL+fPnaW9vZ8uWLeRyObLZLKIo8uMHxvjoRx4hkciyry/EmTML5LIiVquBnl6/4n9aXU1Lpbw9NgYHqv9Vb7MZ6Or2k0xm8XgsjI/Fyvw8dfV2rFaDkmdVipZWN+1bPSwvJTYd55Vu50GRPCSSWYYGFtjXt/k4z2LV09MT4PSpOWw2A9090nOWyQNAKGTF4TRX9UGBVFZssRqwWg1l5EFG34E6zp2Zr6gAyQqT1arn0UerxzCYzVJQpjpXSu7fSyazDA4s4nKZcVdQpdTY2uFheTlJKpmju8evIUwy9vXVce6spEpVgsGg4403NhGPZ7l2LVYxZNRoFNi5K6wQPTW2tLmpr3OwtpYikcgyvMn5trV7iMVSSt1NMGSjrU16zrJZvVJWVikOX9fA2bPzdHX70Ot0XLm8TFQVV6HXS/ljN19OYnXHOBAujhjPrwrscBV/hY+k9bSZio81lYAG1WagGhMJaFJ97WrWSLuhOE4cXBPoUeVubeTAVhCNrsYF2u3Fr43mTWzRFQlXiuLEcHBdYJu7eE6L2RwRm/T+Tej19LpWuCpk6YtEWXGt0RpI8IX7ezn28D5SxhyBtESIoqSIiNIJR4UUwcLIL2XIYc9IWsG8kKSucPuCkFTu84cP9NP5xmDlF+KnxNjYGGNjY+zbtw+ns2iS//a3v83HPvYxHnjgAa6//vpX5LF+FiwsLBAKhXjyySe5/vrricViBINBvvOd7/Cud70LgKGhIXp6enj22Wc5dOjQL+xcf9VRU7Bex1CPCH9eCpYoioyMjDAyMsLOnTsJBoNkMhlyuRyCIPCVfzjNF7/wPAB9+6XaGxmJRFa5iBsMOvbsDREI2DhzunqlSjhsw+E0ldWuyP15c7NxDAYdS0sJZmcqkyuQtuaefmqSVDJHOGxjS5uH9XUpcVtWoSqZtgEWFxMsLiYwmXTs2VtPOp2jb38dQ4NLrJfEAfj8FgIBm3K+sudLfs7btwfwBWwszMerljqDFANwaWiZRKKoULS1eQjXF7OnKm0TqjExsUoobOPRR6cK4aaespRxKczUWRbaKffvgWQ2DwRt5LI5FlymsugJgO07goyORhVTt0x+9HpBUZgMRh1PH5uqOroF6Oyy8UihMxCgdYubujob09NRro0nsNkMtG/1ViRXAKMjMTY2sphMehIbGQ4eipBKSSRRvT3a3eNjempd81wW5jdYUJnVf+OWZlZjaaw2Q1WC1X+4QVEgT53QetXcbjMzM2t4vVZOHJ/lFrdHUXpklFqJshmtWqQOEs2IYFR7sETtOLFUwzKUhINuFsuwES9GLwAYRRRZq/TtsqiuOol4ClxgELKASJ1Hev9nrkkp52oiLahOV511tZ7LKF4rm1WnTFBlgztAxw0BXgmMj48zOjpaRq6+//3v86d/+qfce++9v1ByBVLMDYDPJ41CT548SSaT4dd//deV+3R3d9Pc3FwjWK8yagSrBkAiWKlU9S2rVwK5XI4LFy6wsrLCwYMHcTgcit8qnc7zt3/zDIMDy4TDdvwBo4ZclcLvt7C6mub0qXnNOG9iYpXJwoZWQ6OZ9bVUxZgAuT9vb18dy0sJOju9xEI2TeGwjP7rGnjumSIRmZvbUI7pdpvp7vHjdJs2LYb2eMxEGhwa35bJpGPnriBWq5GrwyvY7UYy2bwSl1CKbDaPoBM4dVIy6G9pc2G15ojFRKYmi8+xdPwoQ/YwCQLSdl46x7btQQ1JlGG1Gejs9CleLTV5kHv/DEYdq7GkJh2/FJ2dPhYXN5SxmLRJGcDhNDE2KnmY9u2v4/zZyipaLidy8cIi/dc1cOzJSUVhWiwY3WUYDAK7doeUEFUZ6gT8LVtcNLe6ia6kMJt1ZXEbIMUtJJNZpSpIDl9VtkcNOvL5PIMXy4Nr1di5K8QjD40hihJh6un14/GYmZpcV8bN1bYS5QBcOeV9aSlB/+EItuEUuRJCZTJpwz+1RTlgUpGkTB6Mqv+XkaRETkOS9IL2vur/l75y6s3ATB6MqhMxWwyaczSrzkFfIIwWQ471jIDbkCWV1TEyIqlNTlXkgppb2lW3q5+GsCGdSE6XxxEy4rdbCXc4XxFT+8TEBCMjI+zduxeXq7hJcM899/BHf/RH3HXXXdx8880v+3FeDvL5PB/96Ee57rrr2L59OyBNC0wmEx6PR3PfcDjM7Gz1OJEaXj5qBKsG4NU3uadSKU6dOgWgmNllv9XyUorfff+POXF8lnDYhtkisL6epG9/iIlr62UEqaPTS3QlpYybSrOhWlvdbO30MD0VZ2qy+jahWsGRL8JSqrqPZDLL5UtL7NgZqprBJD22yPp6muefm8ZiMbBnbxiDUceVS8UxT0OjA50glBGRdDqvRBls2x5A0Ak4HSb0OqFiAOX+A/WcOT2n/FU/OqKNYWhqceGwmXjssbGq+WBms47tO0IcfbK4nedymejs8pEXYWhgEYvVgN9vrdqTuL6WZmlpg8RGluXlJDt2BrHZjYyVbFLu3BVk+MqKhohIm5TF9+Smm1tIJrM0t7gYvhIteyypHLqYgzU6ElPGuMGQNIZMJbMIglBGrtTwePQkU2meLGwuyoTJYJBGr9Foiq0dXpaXEixX2IyUlUS5WHtLmxuP18LktdWy96pUyczlRI3a2NLqoqPTx9TkGjodFd8rp9NIY5NLiZ24Nr7KWz1ejG4tUSglVIYSHmFUmd7L8qhKvrf0DwtBdUNWENCrqEx5sGjx36kSgpVIZjRp8kYVPTPqpQM5zDlWMjoagAtTXnIZAwKQWM/iKPioXHYzFCa+yY2sUnVjLsQ4ZFVbg3qfng/e187i4iLZ7AZnz54lEAgQDAaV+pqfBpOTkwwPD7Nnzx7cbrdy+wMPPMAHP/hBvvvd73LLLbf81Md9pfGhD32ICxcu8NRTT/2iT6UGagTrdY3SEeGrFdOwurrKqVOn8Hq9yl9VMrm6fCnKb//XB5iaXKOzy8vc3Dpzc9KYYHwsqS1JnlwjELQycFEqDq6G+oiDRx+Wsp5kI/HqWpqhAanoWK+H9g5rRfVASlWfxuUy0d0bIJ8X6dtfV3EjMRJxYDQWDe/JZFYZ7cmjrWDIxtTk2qaFwX376zh/bkEzRmpucdHY4GRxKcHlS8tVx48y5ubiRBqcPPLIWDGGIZ1jcHCJZCHeQe4mLB2Pra4W0+Bbt7gJhW0ISNt8SxXqc3q3+ZmaXFe8UersqY5OL4GADYNB4Llnp6t6pUAiuI89WhznhevsbNniJh6XxpCCALt2axPR1ViY3yCdylFfb2dico19fXXodJQl4Dc2Ocmkc8xMF8mfevSq1wu88aZmstk8yWSG5SqLn+otPzVhklPso9EkHq9l0/fJaBTw+61Kn6XHa6ajw0cuV8zM8njMBIK2shGwQRDIl/wRZDZqFaxSU7s+X9zgK30rSrsGSzUeNVlLZkTMRtXXjCXlztZiHESpECmqjpwTwaIiX5bCMd3mLAuCdDl64bIXofA9RhWFTMezWAvzT6fNBGuQR8RZMLWvCxl8ouT8amp20dvbW/gDaJ2FhQUmJycZHBzE5XIpZMvhcLyoujU1NcXly5fZs2ePRgX6yU9+wvve9z7+/d//nbe//e2bHuPngQ9/+MPcf//9HD16lMbGRuX2uro60uk00WhUc/5zc3PU1dX9As709YMawaoBePUUrPn5ec6ePUtbWxttbW0aM/vRJyb5/d/9CfF4hr17Q5y/sEAmrf3TWJ0w3n9dAzPT6+zdG2Z+oTh2Kj4Hgb0lXXSzM3GlS87rtdC7LYDZouPYJqv5kYgDo0nPaZWvqLiRqOfKlRWCQRsL8xtMT1fONMrlRMwWA88+M0UqmZNCL0M2ZqbXFbUMKqeqQzEZXa8X+LU3NJLN5tmxM8jAxQVK3yZ5m1AumFbHMFitBvbuC2O26ImupMq6CdXo6JTGUfL5qXOY5BiGvfsKpu1k5c/KlcsrBAI2njo2SSTioLmQ1SWTW+m4UrBnKcGdm40rUQqhsI2e3gDx9TQOh7HMqwaF3C6rUdmQlImjwSDQ0mrB67OBaODa+GpFVUrGljYrzzw1qYwoK8VHVIvLAOm9mri2yoFDkUImWT3ZTJ4BVcYYSMsLnZ0+jV8tupJS3jezWc+hww1YLXouXijvJzQA2RLJKpEoiVKwajcD1Z6rbFn3jfa/pRuJm6Wxp9OlHYcqtavkvkbVSaTyYFUdV0+OrCjiNeeZK5QynxspmtHlkFEAu6omJ72WxYKJlDGPs9A1mBVEZV7YckDyHwmCgNPpxOl00tbWRiqVYnFxkYWFBUZHRzGZTArZ8nq96PVa49nMzAyXLl1i9+7deL1e5fbHHnuM9773vXzjG9/gne98J79IiKLIRz7yEe6++26eeOIJtmzZovn6vn37MBqNPProo8q5Xrp0iWvXrtHf3/+LOOXXDWoE63UOQRAQRfEVN7mLosjo6ChXr15lx44dhEIhjZn9n792js/+7bNs7fBSH7Fy8cJ8GbmSYTQK7NlbpygDMgGoq7ezZYuH2GqKqclVmppcmvT2UlitBiYn1xgfi2G3G9m5M4Sgg6GBotm8sdHM6mqS1VWtWpVK5Thb2B7c11dHMpmlq9tfcSMRyonT8JUVhRA2NjppbnFhsxl49JHqqeo2m4GOTh9PqbxdNpue7h4/CDqGBhZxOIw4nOaKhcEgLQZEoynW1tKsLCelJHmnUfE/ydi5O8Tw5WXNOK80h+nGm5pJpXK0tri4VKXnsP9wkTipoyfUSo1eL5RliKnh8ZrxeCxKgbTiVbMZGb26wvx8Quk4lGMe1MhmRcbHktgdDq6NRwkFpeypxcWNMiWx70Adp0/NkVOxgtL4iL37wswvSEsKlXxber3A3n11PF9Q2pSQUYue3XvCmM06ZqbXcTjL0/q1z1sispMTawhCQQ0M2pTMLIMgYLLqUQeHlvjQyaaK+VMiWpN7Seg76xtaz9X6Wlrzf6dVD2Ku4veWfmSzyWyxx9BYjGEAMOhVKlTJccwGkbioIwisJ1Pk8jC5XFRfzIVnKCKiy0oELENeGRvGsxllVNjQ5+Z3PrkHk01PZEflfkGz2UxDQwMNDQ3kcjlWVlZYWFhgcHCQTCaDz+cjGAwSCARYWVlhcHCQXbt2KYZxgGPHjvGf//N/5qtf/Srvfve7Kz7OzxMf+tCH+M53vsO9996L0+lUfFVutxur1Yrb7eYDH/gAf/qnf4rP58PlcvGRj3yE/v7+msH9VUYtpuF1DnlUt7S0xIULF7jhhhte9jHz+TwXLlxgaWmJvXv34nQ6yWazhV5B+MRfHOM//s8AZrOOrm4P585KKkHrFjf19Q7m54shjJI53Lmp8tLY5MDhMONymUincwxcXCwzTHf3+Jif26ioZJhMOnp6AwT8VgYGF8uKidWopDi1tUsJ4/OzcUZHoxw4GKk61gLJQN7V5ePM6XklhT6RzDJ4cUHZzgsErHi8ljKVTo3OTi8eryQjDA+vVEwI37EzyOhoTLp4lkCqkrFhNAg888y0UrFT8XmXjCiDQRttWz0kEtJ5iyLs2VunqDGV4HQaaWp2M3I1Sk+vH6NJx5XLK5o0+Lp6OyaTXtMZqIYgSLEGer2OiYnVqrEae/aGGBhYKlPa5A3QjY0MdruxqiolY/tONxfOSY9htUqRGUajnitXlllZTmI26+jdFizbUlXD4zUTCtkAAX/Ayuz0OqOj2vOWK3RkBa8UdXV2PpWxomteptVQHNuObsAWVZDoGjqcBY9TaSHzPEZCKnJ2fk1ghyqGYWBNoFf1/2gGPIUR3iIGAipl7EJcx3Z78fMyl4JwgdiNbQi02orHuSaYaNVJ7/F8ChqdxXMQ7XHWhTzbWhe4kMnhdqT5wP9zC8G8layQx5uXDprV5XHlJCIVE9IECqPAZSFJKC8xuz+67xBdN4Uqvn4vBvUocXFxUdnEq6+vp76+Hq/Xi06n49lnn+WOO+7gy1/+Mh/4wAd+psd6pVFtxPmv//qvvO997wOKQaP/8R//oQkarY0IX13UCNbrHDLBisVinDx5kptuuullH+/UqVPk83n27t2LyWQqPkY0ze/97k949ukp/AErLpee0ZHKAY2RBgedXZLZ/PlNLoK92/xMT69reubsDiM9PX5EEQYHFundFuD8+YWqYy0oEidBEOjq9uHxmDXZUdKmoo2hwep5W1abgV27pV/wpYnsMvwBKz6fpaInSz5vk0nH7MxG1QoYkEzx18ZXWSsQJ52ueN7Xrq0yNbleZoqvhMPXSTEBSvVOLMnQ4FLJOK+e5zdRBoNBK73bA8TXMxWjJ6DQGeguz+2SxpA+3G4LGxsZZqbXlV6+Sti+I8DoaLEEWTb3Ly2uM3xlFVGUQmdPnZx7UcJ4/twCXd0+dIKg5KoVz0siaSdPVDb663QCO3YGCARtXB5arriUIL82NruJ8RKlrUEuH19Nk0pmWYmmKvrdZOzaEeCD05AOzNLtUuVcpQQazMUP2WoWXIW5xHoWHKoZxciGQJuK+FxOG+g0FUnT0LpAt6Ny7lUpaZrQWWjKF4nxchp8Be94aUbWYBy2uaT3Ykk0UG8uPk+Dc42pTJ79W5cY0aU4P+Hl63cewCOaSZIlWMi92hAyBApkK27J4klKzG+DDC7RBAJ8KXYren2p7f+nx/z8POfOnaOxsZFUKsU///M/c99997Fjxw6ee+45Pve5z/Hf/tt/e9mPU8OvPmojwtc51CPCl2tyX1tb49SpU7jdbqV/SyZXo6NrfOGzzzE1uUZbu5tYNMHoSPULit9v5dSJWVZX01JQZ4eXRDzDwMAi2cI4p1KoJ0gVH7Jp+7o3NBBfz7B7d4hLl5bLCn/1eoG+/UXflihqDcxt7R7qIw4MekHTi1cKWXF67pmiciVtJHpJJnMMDixSH3GSTmWrGt7j6xk2ElkuX1olmcyyfYefbDbB7EyGaLRIWvr2S2Gb6uedz2vP+6abm0kkc7S0br6dJ2cwqcuwZZN8NpNDp9dtSq68Pgten1XZzjMadcpWoTzOUzoDK4Siymnw3T1+ZqbX8XotHD7coJj71di7L8zFC9rQTvUY0u02ceBQA0tLGxhNuqoEq7+/uJV48nixJmnHziB2u5GpqbVCh2R1VcpqFVhdTXD2jDTyk43uKytJJbk/EnEgCJSRK/V5d3R6SaZytLV5aG11MzRYvkyxe2+YkYuL4PBq4hAAdCUM3riJb8pk0Rrik0ltZlYpN9FmZmm/Fo2laFLnXqlmlTpDdeP9WiJHfUHpyotg0YvodNIDu+0Zzl4NKr4rs80ABUEvq3qeuaT0vub1Im63GYfeiL/F9oqQq4WFBc6fP8/OnTsJhaQ/lr74xS/S1tbG//yf/xOHw8EnPvEJHnvsMW699VaOHDlCMPjKBJjW8KuHGsGqAZBM7vl8HlEUf6bMGPmvvtbWVtrb25WUeFEUefqpaf7gd39CLJZi1+4Ai4vr1DdIJuRKF/9D/RFOHJ9VLpByUCdIRtyubh9uj4Wnjk1UzE6Com/r6WPFsVYxtNLMyEiUjXia1i2eTQnE+lqK2RkpN6ux0UlTs4toVFJ55N/54bCRbDZXNs6TNhKlY+/ZG8Zo1JHPi6yupsouolCeqn7hvESYdLpCjpLXgsmo4+iTE5tWqhw8FOExVfK6vEm5tpZmcGARo1FKXq82xlxZSXL50jJ1dXbGx1fZuy9cliQPEoHQ6wUNEcpk8oofTBAkgqvX6Rgfrx7iumt3iMuXpFDUWCyl+J+UcNNEFptVzwvPz24aMrptW5CHfzIKSP6nYk3SCkuLCcUr9WyF5y2ftxxEGoul6L+ugYX5eNln1O+3Yndo1Vd5KQEkYr1zV4hMOlc10BSgt9fPtYk11tfSSnab5DcLYbMZGB2J0tjs4uzpecwFhqMvKXsuJVzqippSs3l8I68pcy6F01bcBMyL2qiFUoJVlrelOg/dJpuN6uMk8+AWIJmSfhbqPBmuTNRhKfiuEsksroLXSiwY2EVE5Ta9T8//Gn7bK0KsAJaWljh//jzbt29XyBXA8PAwX/7yl/m7v/s7/uzP/oyLFy9y33338W//9m+Ew2Fuu+22V+Txa/jVQ41g1QCgbM/kcjkMhpf+sRBFkbGxMYaHh9m+fTvhcFjxWwmCwLe+OcBff+opstk8+w+EOXFiDjEPU5PSeEExqsekv/z3H4xoVKBSpFJZ8iI88tCYsiGn1wua1Xy320xjk1MxG8uQQytBinLo6vZjMulpaXExXsHz097uYW0trfjBJifXmJyULoSyd8po1HHhwkKZMqZGqdJmMkml0haLtJG4vJTcNFVdNpsfPBThyScmFK/aQskmpVxZU0qc1JuUjU1O2to9rK2msVj1mi03GbIPSt7O0yTJ7wjgcJhIJDJMTa4rxLcStu8IcubUPPF4RnnspiYXsWhSCXTdf0DqkKykNsnhpv2HGzh/foE9+8IIAlwaXGJtrajoKWqcaisxlSwuJeh0Att3BKirt3OlijkfpM9NXb1dIYjy+66Oj1hZkT6318YrjwQBbDY4c2qWaDSN1WpQyLXaJ7dzV5Arl1c0SfsgZ6NJ533gYD0rK0n2H6hjY24DouU5V1ZzsaAvXxIGKgqq8j7Kw0FLoS6GTotgUR1LKCmRLv0TTO31Wo9nNWZ5g4oUGlQpo6sZQapV1InEs5CKGZhdNhMq0DeH3QiFH0u9KD1inCzeguzW2up+xcjV8vIyZ8+epaenR1OAPDg4yK233sqf/Mmf8Od//ucAbN++ne3bt/Pf//t/f0Ueu4ZfXdQI1uscslolE6xsNvuSCVY+n2dgYICFhQUOHDigmNlzuRyiCH/1yaf4t385j8EgsGdvgOMvlI9c5Iu/3W5gX189Yl5k5+6QxvAtwx+wEghYlbGOujpHHvG4PSZWlpMVy5hldHb6WFpOKGNEKOZOLSwmuHJ5mV27QwwPryhen1IsLSZob/coAaP7D9STy4sMXlxQSogBtm13lBm/0+m8EuJpMAjceFMzyWSW+oijYl9gKXFSp5MrhcGJLLlsrqyyRo1wnR29XsfRwqhTDkY1GothmzL5ujZTTjjlkNBt2wOMj69SF7bT0eljdna9zGxeaYw5ObGmKDU+v4W+vnoWFjbQ66HadLr/cIMyvlWP89o77JjNAivLIg0Nzs2XCqx6RBEeeUjK3Ko0zgsErDhdpool1XJ8RHOzC6NBhz9gpa7OzqUhLdEDafFgampNUSgTiWI2mqxENjQ6GR2JlpErNQ72R3jhOcl7eOXyCn6dDrw+7DZtmTOqAuaMCGYV80lni18DsNqNgMpnVvKYavKWzmvzqkxWI9UiHErN9KUio9mgCjtVSVhrhR8TvT7PSkbH0Igfs1WvjAXja8UKHJ/BBBlICTmF5229rrjZ93KwsrLCmTNn6O7upr6+Xrn9ypUr3HrrrfzhH/4hn/rUp16Rx6rh9YUawaoBAJ1Oh06ne8lRDel0mtOnT5PL5ejv79eY2dfXM/zhBx9idDTGr13fSCqZ5PgL1QlPuM6O3W7UKE5Op4nde/zkcnkGBhapr3OQTGYrXgBBGvHkchIBWI2l6en14/aYuTa2qolRkJO4S4NK1SOeG94o1ci0troZVOU3qaHeqstk0sUsI4teIi0mHSajjqdUI8pSyKXOjz9WHOfV15tpbvGyuJjk6nAUj8dMfcRRlTjNzsQRBAGTUUdsNcWBg/VkMnkGBxaVgFGQvGRra2mNH6g0GPXGm5vJZPIMb1RXefb11XHhvBSKOryWZnhYuq9sNl+NpXC5TDz/3Mym23ldXX4eKozzlBoa1RhSGedVCIPNZPJcvRLHatXT2eVXxnmzM+VEz+M1EwzaNIS7dJy3Y2eQXE7k+PPVSdrWDg/LS0mWl5PKBqDRqGPnziDWQop9KGzn6vBK1QqdfF5Er8/xxGPjZLMiTc0uGhsdxKIpTUWTmlTKMBT+EMqmspr8KZOKQGVKiI7epFWw1te1fYEutwnEImlSE6zSvYi1kggHl6M4TswiYFapW6Vvu07FuDIqpVIsZEiYDXnWczA8X08ylcVdUKgMBZ0sQRZbRrqteY+bW25tgzwc+q1mXi6i0SinT5+mq6uLSCSi3D4yMsLb3vY2fuu3fotPf/rTL/txanh9okawalDwUo3u6+vrnDx5EpfLxY4dO9DpdAq5mpyI89vvuZ8rV1ZoanZy5dICc3MpwnU22tq8Zf6lzi4fS0uJMgP02lqRtOzrq0MQpFFQPJ6pWBa8/0AdZ1X+JbXhWy52Npl0HHtyclMfT//hBo2ZXTZ8pzN5Bi8ukM+L7N5TVzWtO5XMcWloiY5OHyePz7JtewCny8ToVW2NjMOhw+83l633z8ykmJmRlJqdu4J4fRYW5jcQhPIqE/m5rcbSzBRIZGnAqF6vI5fNcflKtGJUg4zde8I889SUYiCXIxzm5uLKe3OoP8ILz89UfP1k03b/4QaGBpfYf6Ay0dPpoO9AvYZAlBZa794TIhC0aip1SuFymYhEHIoSKC8OSNuQLmKraZaXEphN+k1T9J1OMwMXl1iY36hYnwPQ0+tncmJN2diUkcnkOVcYJ+7dG2Y9nmHX7hDz8xvKeFGNPfsCnD1dJOwT11aVzkOfz8LWDi9ut5ljx8qXKeRf1KUjQn0eRYoSDFpClUiJysgPyolPLpvXBGlZVYSs1L9V+tlTjxPzOq3nqnR8aDUVFaycirilMtLvGr9bR85h5oVzPgTV142Fk0urVKsP/s0+en/GKIZSxGIxTp8+TWdnJw0NDcrt165d461vfSvvete7+PznP/+K9BjW8PpEjWDVoOClpLkvLCxw9uxZmpub6ejoKBQ1S+TqxAtz/O77f8zycpLt2/2MjEbZiEvHm5vdYG5WIhiBgJWtHV5MZj0nj89UNHzLKC0uNhqLoZPDVyTz8ovVyIyORAkGbTz5+ARNTU4am1wsq1K6ASwWPdu2B8uUA3UqerjOTle3j42NTNV08WBQiiOQL/xq5UQOjoyvp1lY2GB8vHreVkenl6mpdSWY0uez0NHpI5XKKjlfO3YGGRmJVhxjyuPTvv11DA0t09buxeEwMlrSFyi/xqXEqTQYtXd7gMmJVaqlupSms1cieuNjURoaNw+DtdkMpNM5ZZzXvtVDKGQrjCFXldfY4TQpHjE15G3IpiYnDocJr9eCP2BlYGCxzG/W0ellYWFD8c+V1uf0bgtQX2fn6ki0jFypUclHVl9vp6XVw/q6tFhw4GA9z27iLVxeTpLNZnj4oRlVQKleMejLCpbFpPVCaTr/0nnsqq1Ag0lbZ1P61qU2tF4pcnmFrBnM2kT40nddTfQ2Ujmc5uL/nW4ziMUIB4OK9Inqc9dLt5t1GUaWc8wuuPA4ir4ruWPQUPBfCQL03PjKbOzFYjFOnTpFe3u7plZmamqKt7zlLdx66618+ctfrpGrGl4WagTrdY7SPsJqBEsURa5du8bly5fZtm0bdXV1Kr+VyA/vuco/fPkEy8tJ+vaHpXTsKlxtcTFBR5ePY09O4HKZOXAwSCYjBYTKSdk6HRw4KBm/1chkigXJFqteGuelctTV2zXJ5DIcDiNt7V7FozMxsaZkFoVCNra0e0ilMqSS+U03vuojDkwmveJfMpl07Nwdwqoyqm/ZInmhKqkXIKkser2O2dn1wvOuY2pqhalJrUF+a6eDyYlVjZdreTmppJ/bHUbeeGML0WiyTC1QQ13vcuG8ti8wGLQxPb1OpN6hMYeXQqeDSKODhx6Uxnmy0iIreqlUXgnbrJTOLhM9p9NIS6uHdDrHocORsiR5kDx2brdZU4p9dTiqvJ7BkJnebSHSqdymSfBbOzwsLyc12VSy38xk0nHlygr19Q7GxmJVPXa5nIjFoudYYVN1S5ub+joHCyVp8Af7IxyvoOrNzMSZKTy/N1zfSDKZY9/+OoYqdFoC7N7j49RJiYynkjnOnJaIniBAd7ePLpsZxjMSCSr81s6UlCrn0JKvRDKn2RoUSkxXpRuI6mOlMqLGv2UqIWsWY1HtKhsnxlKgClI3V/mQ2kzS59umTzE+7wIEUqs5TOjJISo9hEGbBV0CvBHrK0J45DiZtrY2mpuLY8aZmRne+ta3cvPNN/OVr3ylRq5qeNmoEawaFFQbEebzeQYHB5mbm2P//v24XC6FXIHA5/7uef7pK6fR6aD/cJhodI3GJjvjY+WER9qgCyuKUyyWUtQOu93I9h1SfY0AZeRKDY/XTH29QzPO29rhJRSyMTm5xrXxVcJhG3a7SdnKKsX8/AZWq4FMNs/GRoYDB+s1xEFGR6eX5eWkMoaDwrbXmeKW2o03NZPJ5jdNXlf3+EVXUooPKBy20drmIb6ewWoVOHVyQVHsKmHnzpDiX1I2Eq0GRdEDubKmMgm5cnmFkatR9vXVMTGxSv/hBlZWEgwNahUhi0VPT29AozgtLxcVPZvNwKH+Oux2E8dfqE545JBRNcmD4uh2bjZOOi2l/FfKypLhckpjw6XFBG6Pma4uH9lMnsGhJRIF31PvNj8T18rHeWq/2d6+MKlkjh07g4VqmvLFggMH6zl5YlZ5H0ZHYoq/KxSy0dbuwWY38tTRiRcdOat7L+XaH5tNUhPn5zfYf6C+bONVhijC8PAyW9r9gIBJNdIr4UAFxqTKiyrrBNSSpNLIB3XUQlJlngfIlHYPisWfj6xYfcMwJ2rrepxOE7J3K+iUDPJeU57RWTcA1sJYMEkWDyZ0ToGvjN6KyfzKXKrW1tY4efIkra2ttLS0KLfPzc3xtre9jeuuu46vf/3rSjZXDTW8HNQIVg0KKo0I0+k0Z86cIZPJ0N/fj9lsVkaCiUSOj/zRIzz04CgOh5HGJhvPPlP0FNXX22nZ4ma1YOL1eC3U1dmr1qnE4xkmJ1axO0xMTa6xe08Yk0nPpaElTf5Sc7OrLFgTtGOtg4fqMZsNFXsCZWzbHmByYk05dhnRE6TLxsCFxU03vvb11fHUsUklMV0metPTa4yNSiSq/3CE55+r7F+am9tgbk6KIxgYWGRfXx3ZTF4iY6pQTUGAnbu8mjGmeiNRp5NyviINjk2rhaw2A52dPuX5ykpPMGijfatUIyOFbdo3rYCx243Mz20wMjKtCRgdU40hG5scVYmTrE61t3uw20x4/RY8HrMmSV5Gb6+fCZUPKhYtEnNZnfJ4zQwOLP3U4zy53FkONz10OLJpe8D8/AbtHV4ee2Qch9PEjl2V0+AP9ZcXWksxDBLRNBgEfu36RrJZkbZ2T8XXyGzW0dxi59rIKrjcmu7BUsUqmRE1v9FLT19fosjYLMXOwFIiVMbvN1G7SndA7Ko8rVQejKpziq+nobD85zGmWMjrqAOuTnnJkcdQeIaywb21zf2KkSvZO9rc3KwpRF5cXOTtb387e/fu5Rvf+EaNXNXwiqFGsF7nKB0RqhWs9fV1Tp06hcPhYO/evRoz++xsgvf91wcYuLhIJOIAIcfQoHaDSz0mkSIUzMSi0oZYJYWms9PH8nLR8C6PSQyGwsXbZiSXzXPlyoqGcJViz94Q588tKNtcCtFT1ddUS4EHieidPDHLof4IZ07P09Xtw2LRc7mkNw/KO/pAS/SaW5x0d/sZG1utqnQYDNqNuXL/ksDoSJS6iI2zZypvUYKkKAkCPPyTMQDa2jyE6+1KWTBIyevBoE0hZWosLGywsLBBOGwjGLDhcBrZ11fH4MBi2WZcU5OTbDav1PmUBox2dHppbHKxOB/n/CZm9UqKk9droWWLndVYnKnJND29AYYGl8s2P2Ukk1kMhuICQ+82Py63mYlCZZCMQ/0Rnn+unDipy51veGMTyVSOHTtDDA6UR4VAQR0svOfra2ltGvyOIHansRAIO1n2vTJMJil645jqPvURB60tLtbW0wwOLGE262lr93Dh/CK7TCbyYl4Tj5DJiRqTuslSJDZQTrCSqawmuT2bzikFzTkE9JuoX2WRDqp/5wUt0cukc8odSn+85LFkLCPQqBOJpXLE0gaml1zS1mMS8oj4C3LZzt8I80ogHo9z8uRJmpqaaGtrU25fXl7mtttuo7u7m3//939X4mpqqOGVQI1g1aBArWAtLi5y5swZmpqa6Ozs1JjZz55Z5K8+eQy328y+vhBXLi+zulpd4dm5K8jISLFw2O0x09npI5PNM3BhgXQ6XzU+AaT8pfPnFjhwMML58wtsafPQu83PeEkEA1RWitREzx+wsq+vjrnZeFXDtiDI6oM09pLJiJwE73SauHYtRmOja1NzvdmsIxi081CB8Pj9JkJhI4Jg5tLQCrmciN1uoL3dW3FEJPuXPB4zDY1OdAgc7I9w9cpKWcCn12sqjOGKZGZkJKoQIKnb0Usqlee5TTxXrVtcJDayGgO52axn954QJpNkug74bSwsbCihm6UQRcmzc/yFGdbX0oU4AmfZGHL33jBDA+Xv+cpKUjn2of4ImYw0zitNkpdRSpzUHq7WLW4i9Q4sVgOPPTpe9XlD+Qap3WFk526/ok6traU3NatnMnkGBxfZtTvMc89MS5uYIZuG4II0eu3s8pdvkE6vK2Po+oiDzk4v6+sZ7HYDhgzkSkZ6uRJis76RBXvx606X1myuK/m4l2ZZqcePNocJde6V1aIdL6rjIDIlK4cWc3V/lsMukcBoBhoBnTHH8QkHoCOVln73eFosdIa9xFfSvPH9W3i52NjY4OTJk0QiEQ25isVi3H777bS0tPAf//EfP1XAcg01vBTUPlE1KJAVrGvXrnHp0iV6e3tpaGggk8kUzez3XuXPPvoYyWSOvX0hzp9dkMzH20PMzcbLcohKtwBBGu/IY0K7w8gNNzazspwsM+Gqcfhwg2LGHhosj2CYnlqjvt6x6aaW0SjQ3u5RDNulWVvJRA6LRU/vtkDF48hJ8JJx3sPKipTAPjW5xrVr2mBOOb9KbZxfWkqztJQG4rg9ZnbuCqLX6Xj2mepKRyTiwGDUabYRBQG6e/x4fRYmxmMIAiQSGcbHNksXN3D+nORfkjcSk6ksg4WNRJDiCKan1stITCqV40whFX3X7hC5fJ6uHh/XVGXYapR2BqrjCAIBK+1bvdjsBp59ekoT4VCKUuKkEFyXSTHJy2XV1TA2GqO+3sFjj44TDtvY0uYhHs8wqOq0FAQ4cLB8nBdfzyjqlMWi54Y3SoGw4bCtbBMTJELd3RtQ3nO1kilvFW5sSH+kVPMFgpQo73AYFbJnMunY0uKFVe1rVaq9lgqkiURG45uy27UKl7prMF2ihpXmXplNOoXLZfPacWLpeWSTRaIn6rXREZlkBkywUbjJbU3z1KAUuyCfzq/d3MTv/+99vBJIJBKcPHmSuro6tm7dqij2a2tr3HHHHYTDYb73ve9hNBpf5Eg11PDTQxCr/Rlfw+sCoiiSTkvK0tDQEIuLi6TTafbs2YPb7VbM7IIg8L++eIL//b+OA9B3IMSJF8ovEnIMwuJinEDAXjEoUoY8GlN7aXp6/RgMOsXPIscnbLbhZ7MZ6OjyEV1OEmlwllXIgJSb1NTsqprwLleaWCwGjr8wXZbQLSMctmF3mMr8Mi2tLhoiTuYX4iQSOXQ6QSEVldDS4iKVzjE7E8dmM9DTG0CnExgaXFQee2uHh+hKatM6mp5eP6IojdXm5+MVNxi7ejxMXosrlTVq2O1Gunv8uF0mzpydV6pcKmH/gXrOnJ5TvGZQPoY82B/hRAmhLoW83Wh3mOjulgw5Q4NLmtiLF4veAHjjTc2kUjnmZuMV/UsScaqv2DXpdEqdlqIojfY2S4I3m3X09AaVkTUUc8LkFHubzaCM86rB5TJRH3EwOxOns8tXqEDSbhV6fRa8XkvZ87nObOF2p5ntW4o/c7NZHXWG4nsxuC7Q4yi+7oMJHT3W4teH1gW6VV9fyws4C7LWXArCqqiF86sCO1zF+16JQ0eBNKVKgkVHciba9MUR73gCWqzyvwW2OIrEcF6no9GQ4uKGwKGGKIbACh/6wU4Wlz247Cb0awL/34VbCTarpLifEYlEghMnThAMBunq6lLIVTwe54477sBisXD//fdjsVhe5Eg11PCzoaZg1QBAJpNhbm6OTCbD4cOHsVgsZDIZ8vk8qVSev/rEU/zHdwawWPVs3eqqSK5AMkyvrCRp3+pldDRK/+FIWVI1FAmPejSm3vQyGnUc7I/gsBs5fXqT+pewDYfTpPTOyZ2C9fV2Wre4icVSxGIpDHrdpvU5oZCNsbEY01PrhaytEFZrsSgYit2ElS7m42OrjI+t0tnlw2YTCASs2O16Lg2tlHl+erf5mZosKkUbG1mFQMqP7fdbuHJleVNypd5KlFEfcdDa6iJW8Jtt3+FlcCCqqDWliMczGAw6nnxyAr1eYNdu6XlfUW0kgjbyQQ31GPKGG5tIp3J0dfsUr1sp1NuN62tppa7IYBRo32rD63Nisxo39S/pdNC3v54nVAn4kQYHzYUk+aHBJfR6gZ27wlWLvNfW0lw4v0BXj58L5xekyI2STUygQJy8GnIFWnVqa4eHpiYXc/Mb6HRUTP73eM0EAjYle01J/jfrC72UBpaWNshkxIqfL4MgeZPUSKY3N7VnMqLisQLQldxD7bkSdVqlqdwgr3rcjIhZJfgIJXkPamUsV/IhyCQz4ACdkCcm6vEIBmZXnBgAYQ28fssrQq6SySQnT54kEAhoyFUikeA//af/hNFo5Ic//GGNXNXwqqJGsGogHo9z6tQpdDodXq9XQ64WF5P8zm/9mPPn5jl4qB5IMzQUrXqs+ogDi0Wv+JbkrCM5XDQezxCLJRFFYVPC09Do4Nr4KjPT6+h0Uuij221m5OqKMp7Z2uEhFktXVG1k31VXtw+TUU8obMftMTNwcbGMbPRuDzCl2iaUsraKm3k9vf5CbpK0Vl8Ne/aGGBpcJpHIKllJbo+R7u4AiUSOwYEFdu0Oc/7cgmY7UI1MJi/lLx2VDNvVKn+q5i+pfDzXv7GJVDLH9h1GJZy0FAcO1SmZUrmcqNlI7On14/FaMJv1GjJTCYf6G3jy8aJ/yeezsLXTSzqVY3BgkUwmXwgirawUZTMi42MJfD43Tx2bUkagk9dWNXlWJpOO7TuCZZ41OWAUoK7OTs82P9GVFBaLvuIY0m430LrFoxBzOXJDzp3y+qwsLm6g0wll8RJqeH0WRBGl7sjjNdPR4dOMnYNBKza7qWKERyqV4+yZecJ1UtOA1Wqk/7oGpqfWGB8rKqAGBISS39ZlRnT95onqpblX6sOlstrMB5tNO07U1OiUPO7aWlqTe2VSdxhatB2GMvky6rLMJXKcH3FgEPUEglbe88Ft1LWrgrt+RqRSKU6ePInP56O7u1shV8lkkne/+91kMhkefPBBbDbbixyphhpeHmojwtc5kskkjz32GA0NDdhsNubm5tixYweiKBZM7yJPHZvkJz++ymOPjnBtXKpt6er24/WaGRtbVS7o3T0+5uc3Nh0z9W4PsLaaor7eQTqdq3jh37EzyNhorOK6vbSh5qOx2cm10RjDVUI9oXLvoMtloqvbTy4rXQB37AxV3SaUceBQPadOSKv9HZ1eAgEr01PriloGlb1mpfi16xtJJqW8p8GBRSW7SY3NPEWy38xi0fH4o+V1KmqU5mDZHdIoUABlK3DbdjcXzseqHkOvF9jXJ41wt7S5qat3sDAfZ/hKVLmPwSCwe2+YEy9UH+F6PGb27A2zvp4pizKQYbHo6er2V9xubG11Ux9xEF1JoDfoNh3DOZ1GmppditHdapXGzuqeQ4/HTChs5/Kl6huZPr8Fj8dCNpunocFZlvwPKMRJ3e+ofU4G9u2vw2jQcfbsfNkGqoyGRge5nFgWvNrY5KSpyUUslmT7UoY95NnVVPQfXokLdNhV6fsZI1uNRVI0mjexRVd8rcc2oLUKpxjZEGizqUaCGSMdqmNNJyFiKf83wLlVgZ2qcWI0A54CWRtJ69lqLR4nms8SsojMkiRt2+D4fAMPHw/yiX88zJvfu7Xyyf0UkMmVy+Vi27ZtCrlKp9P8l//yX1haWuLhhx/G5XK9yJFqqOHlo0awamB2dhav18vk5CTDw8N0dnbi9/uVrZpEIsGZM2fQ640k4gEe/PEYP7r/KnNz0gVha4eX1i0uRq7GNg2KPHBQ8vCoyYzDaaK7x0c+JzIwIG1gnTw+q8kpKoWazLS1ewiHbcyWGOz7D0sp8Jt9un/tDY0kEhkEncDgxcoJ25WKd2W0tLqJROxYbQYee6S6wiNtJWqPY7bo6e0NKH6z9fU0+w9K+UvVoCY88sW39MJvNArs3lNXNWsMJBKyr6++oLQts1zhwi/5jgKKuV0NeQy5tpZGr9dVJEUyHA4jLa1uRa00GnV09/ixWvVcvrRINJrF5TLR0OgsyzVTQyZFsWiS1jYPG/EMAxcXNYTW57fg81mrhr3Kr5/dYWRwYKli8j9IY2ezxaAEwcqQDfrJZJboSoJsVmSqgslfRmOTg2xWIk46nUB3jw+328LkRFGVa2lxsZHIsrCJMtrUbKc/oWO/VWBbuKimXVoX6FJ5qgY29PTaigrWxTWBbc7i15cEI35RIjvpvFZpKiVrpR6sKHo8BXVsPm8gpCv+rJQSrI0c2PTFc9jhKZ5TnCxek0jGGifvy/I/7uzE7PBy55V3VX3+LxXpdJqTJ0/icDjYvn27Qq4ymQy/9Vu/xeTkJI888gher/dlP1YNNbwU1AhWDSSTSTKZDKlUitHRURYXFxFFkWAwiMPhYHR0lHA4TFdXlxLCJ4oix1+Y4YH7hhkfW+XBH48A0lp8fb1DMf/KUG8BVoIgwOFfaySxkUGv1zE4sFjW9ScIcPBQpKohuanJSVOzC4tFz2OPVic8er1A3/56Td2K2aynu8eP2aLn8qVl1tfS7Nm7OVGRUrlDnDg+S329nVDYxMpKgolrSYXYmc06tu8IbWrSdzikvKlUKsfV4RUWFsp9V3I4aCUyEwzZaG/3sLGRRSfAmU0Ij9NppLmlSHikC78ft9vEaGEzz+HQ4/MbuTZeXYmUCc/iwoYyCixVI70+C35/dcIjCFLJtMdr5uqVaNkmpoxQyIrNZlKyqmQoamQuz+JiAlFk08WC+ogDvU5gclIiN0qMwmycq4U/DBqbHOSyohLrUQnNzS4EAfxBG3pdecAoSOR7I55hYaEycWppddHe7iW6kuTUJmGuLa0OFhcT/HrezF6nyP7mqPK1Ccw0qcZvpURnYE2gV0WwZtMCdSbp/0kELCqnVSlZu7AqsF11rJU0eAsZWrOikTohU/W+ObHo2bqwJrBTRbDy+ix6HXi9McZyOj55bw9/9+9v5Prbi6nqPwsymQwnTpzAbrezfft25fdUNpvlAx/4AJcvX+axxx7D7/e/rMepoYafBjWC9TrH6uoqy8vLeDwedDodOp0OQRCIRqOMjo6ytLSETqcjHA4TCoXw+/0Vw/jOnJ7jgfuGeeD+q4qK1dTkpLnFhcmk4/HHqo+0LFZJzZGLdkEiLz29ASwWPZcuLZNK5ejuLs8OUsNmM9BRICHhOjttbR5isaTGcC1HLMhp2pXg8ZjZtiMoBWlWITwul4nGJlfFxHSf30JHh490Oksmk990pOXxmqkL25XcKUGAzi4fPp+Va9diTE2u4/NLREXdgVcKf8CK12thYX6Dzi6fMgJV+4/kyprNVMa9+8K43WbGRmOMjlYefYXDNiwWg2ZECsWNRJ1OYGkxQSaT0/inShGJONCpCE9Li4uGBieLiwkuX5Zej8YmB7kcmpqiUjQ3S+Men9+CyaznSoVA2JYWF4lEtqqHrj7ioLvbz3o8zcnjMxWN6gBt7R6i0aRmDC6rcnKKvdNlYmkxWTUnDKQg1vn5DWLRVJEgJ7IMXiyGm25pczA3u8HGRp532uzscOU40FR8T0oVqkspA13morI0tCbQrfr6QgqChU3BlQx4VZ6rSZ2ZxnyRrJUeez0LjoJpazgusFWldl0TzDSL0veqyRXA+TXY5Sm+mEZjhqhooM67zCMLNt7w1x+i98DLK3DOZDKcPHkSq9XKjh07FHKVy+X4gz/4A86cOcPjjz9OKBR6WY/z0+Do0aN88Ytf5OTJk8zMzHD33Xdz5MgR5evve9/7+OY3v6n5nltuuYUHH3zw53aONbz6qBGs1zm+973v8Z73vIfrr7+eI0eO8Pa3vx2/38/HP/5xgsEgH/jABzCZTMzNzTE/P086nSYQCBAOhwkEAhXJ1sDFRe6/b5gnHhtnfT3D5UvLha0+6eKkHgUFAla8Psum5KGusBGIKG1vVdqsC4WsOF3mioZ3f8DK1q1ecrk80WhS4yEqRbjOjtVqYKxALioRnrp6O2azoar3Bor5VdGVpKKyyKZn5T4NkqKyGQnZ11eH02lifDxWljEmo6nJST5fPq4q+o8EotEk62uZTZUZdXQEFD1A6oDQunozyUSOaLR6sGzrFhepVJ5g0IbNVr6RCLClzc36WnWFJxy2sW17gHg8y8kTM1W3ILd2eFheSmrGnHq9QFe3pMqNj61isxtZWky8ZMLj8RaCcDN5BlUktbPLx9xsfNMWge4eHzqdgNttYWZmXfkcae/jZ3JyTQneVcPhNNHV5UMnZLgyHCO6Ir3Ov2m30+3McrCpSGpHckba9EUlqXSsV6pKqVUoNdkCGIzr6LEXidCVpJ4OS/GzmhWLRvfS4w6uCfQUyFhphIOaYKXy4LRkmIwb8fhX+NZkO/947IMVXsWXjmw2y8mTJzGZTOzatUshV/l8ng996EM899xzPPnkk9TV1b2sx/lp8eMf/5inn36affv28Y53vKMiwZqbm+Nf//VfldvMZnNtfPkrhhrBep1DFEVGRka48847ueuuuzhx4gRut5tMJsO//uu/8uY3v1nxMoiiyNraGvPz88zNzZFMJgkEAoRCIYLBYMUk5OErKzxw3zD33zesVKkEgzbatnoQ8yKTE6tMT1e/6Le1e4ivp5XNQZ1OoKvbh8djVkZa7Vs9rK2mN93wkzcO5RiBTDrHwMCiptR5a4eHWDRd9aIPknncaNQzcW21qsKztUMa/ZQSQYXw6AQ2EhLZ2WwhoKPTy9JSQrlPY6OTpmYnKytJhfB0dvpYXNyo6KOS0dnlY2U5QV29A5vNqImekNHV7WNuLk50pTJ5CAZt7NgVZH0tzamTs1UJT3ePj5lpLQnR6QTat7owGDKsrIh4PDZmpssDTbXH8TM9tcbqalozChwcLBY79/T6mZwoL3ZWo3ebn1xOxOe3liWqq+8zPr5KfL08J0x+zxwuE1eGVpiZ2bzbcmw0pskbayjER8QK8RE9veX3KUVHp4tr4+vk8yjK2I4rGzQYNzjYWCTjF+M6tqlIUSnBmsFIvWoTcC0LzsKP6EwS6lVG9c3ImYh2I1FNqErvW6qMjWKiXS99NjdEHR5zipE1AwZ3nOGdt/Hhv95f9XV4MWSzWU6dOoXBYGD37t0a+8JHP/pRHn/8cZ588kkaGhp+5sd4JSAIQkWCFY1Gueeee35h51XDq48awapBwfT0NG9729uIRqMEg0FOnz7N/v37ue222zhy5AhNTU0ashWPxxVlKx6P4/f7CYfDBIPBisnI42Mx7r9vmAfuGyaXFxm+soLZpKej00sikWPg4oLmwr1rd4jh4ZWKFz4Zb7ypmVw2z9horKoStGt3iOErK2UXNXmkJQiQz4tcGlre9MJXepxgyEQkYiexAZcLCtyu3VJ1UGl3X+lxxkZjtLS6lMypUqL1YscJhmzs3h1icSnBuTPzVbcXKx2nSFItXLsWIxCwcfnS8qaF1jt3h7hSuI+a8AxcLCo8W9osTE+lNaS10nGSGxn8ARsLC/GKaqL6sUphsRikCIdCsfPsbHVyvnN3iMtD2g5DWUldXU0xOLDI9p3l96l2nEwmJ5Eth+QHU5vkKz1WKQ4dqkdEIJ3KMji4VDE+orPbxejVtbIOxN92OOgK5djtjyq3nV8T2KEiOqVeqLGEQKtV1REoFmMSJhLQpMrIKiVYw3HYKgeL5rXVOKXjw+m8kYhO+pmYT0FIHViqUrDiGPCaEkzmzRh7/dz4ud+p8kq9OHK5nBIts3v3bkVJF0WRP//zP+dHP/oRR48epbm5+Wd+jFcK1QjWPffcg8lkwuv1ctNNN/GZz3ym5hH7FUONYNUAwMWLF3nLW97CG9/4Rv75n/8Zk8nE9PQ0d999N3fddRfHjh1j165dHDlyhNtvv522tjZNUXQ8HleUrfX1dXw+H6FQiFAohMlkKnu86ak1fnT/Ve6/f5gXCt2B8oU7m81jNus4/sLsprEHBw9FOHG8GI0gRwnMzhQN9i8lPuHgoXrOn1ugq9uP0ajj0lB5593BQxFOnqi+3VhXb2fnziDT03EuXliour2ojnyQIRvNXS7JaN7S4i6oRJtERxys59RJ6Thyt2M2o1Xl9h+o5/SpuU2Ps/9AHSsrkg+oWiJ6pQR3GXL6vs9n4fTpuU0Vub79dZw9M685jkx4YqsphgYW2buv/D6l2Le/jnNn5snnxcLrZmZ0NKohPHv76jh/dvPj9B+OkMuLZNLaUaAae/eFuXB+oWKMh5zmrtMJHH9hetOojz17w1y8UDyOrIwZDFJ8RDSaorvHydXh9YoF0x9wOGlwJzkUKSpo41hoofh6X1gT2K4iPtcS0GylIhZ0JoL5ovJXapAf3YAthUgHtfIFMJjQ02MtvlbjCYGWApErjXC4sAY7CwRrLqmjyZXiakKk7SO3su1te6q9XJsil8tx+vRpAPbs2aMhV5/85Ce58847efLJJzW9g79IVCJY3/3ud7HZbGzZsoWrV6/yiU98AofDwbPPPlsrnP4VQo1g1QBIUQ3f+973+MhHPqIhTiD94pqfn+eee+7hrrvu4vHHH6enp0chW+qkZJBiHWRla3V1FY/HoyhblZKTF+Y3+PGPrnL/D4d59plJ+vZHOHd2nu5eP4gwUCEzarP4BJB8ST29fsZGVxXDdCVU2m40GHT09vqx2oxcHV6ho9O36WOBttpFNrknEhlNsOlLqX85fF0DCwsbFbO2lMfa5LnLtTs+v5Xnn52qmDmlPk5plIU00nIXxpBLLynuQu4M1Osls7fDYWRkJMq8qq+vu8fG5UsbVc3jAG+4oZFUKkc6nWfw4kJFJezgoXqOvzBbFrAKRcJjNAo8/dTUpqR6/4F6Tp0sEvhKeVn7D9Rx6uTcpsfpO1DHmVPzhMI2WlpcxFbTDA0sap5n3/46zpyer0p09XqBfft9rK+nWFkWmakwMv99p4u2SIYdrqhyWykpuiaaaBaK7/dUAhoKBCuTB6NKhRpJCLSp1K0xwUKrqhh6XtQTEiQStZwGn+pvpFK1a1E0EBCkn0812QIYzxvZYkwVzkfHFneKUbOJ/q/+Ll6vt+x3zYshl8tx5swZ8vk8e/bs0dgSPv3pT/Otb32LJ598ko6Ojp/quK8mKhGsUoyMjNDe3s4jjzzCzTff/PM7uRpeVdQIVg0/FURRZGVlhXvvvZc777yTRx55hPb2dm6//XaOHDlCb2+v4oUAKQJCVrZisRhut1tRtqzW8j+vV1YSPPijUe6/b5hjT14jnc5jsRjo3SaZtUdHYjS3uDQbh6VQxydA0SS/qqrseSl5UQaDwN6+OtbX0rhcZoaHl1hc0Cpb6myqSnA6TVIiutvM0WMTGpO7GtUiKKSsLQcLC4Wuv0MS4dkMMgFTb2KWjiFfjKACXH9DE6l0jsRGpmIC/mbHEQRoaDQTafBisxp54vEXC0bVHke9kSj3M76Uc5YrfRoapMiOWDRZVtNUWiJdCoNBxxtvamZ9Pc3oSIy5KmPIamRPTnPPZvOYzDpOvIgSu22bi8HBVYWUSdluds0I9b83BjEJyxysK5LWUqIzIZpoUhGsxYxAwCh9PZ4Du0oYuRwX6FRtApaStSVRj79AsEp7Ckvvq/76VM5Ag774x9BIQsdWh/T/a3EdW70pzrZEqD8iqUuyh7PadrIa+Xyes2fPkslk2Lt3r4Zcff7zn+drX/saTzzxBD09PZse5+eNl0KwAILBIJ/5zGf4/d///Z/PidXwqqNGsGp4WYjFYtx3333ceeed/OQnP6GxsVEhW+qtHpBSlufn55mfn2dlZQWn06nEP1SqrVhdTfHwT0Z54L6rPP7YOFabgbo6B0ajTopvGJJGK2p4PGbqI46qoZWBgJXuHj8mk44nn5ioeuFzOIxsafMoxnwZW7d6CIbsTE6ssrycoH2rT6nVqQSLVU93t58zp+exWg30bgsg6ASGVDlfZrOObduDL0oa+/bXkxdFDVFUw2AQqmZ3KXlXHhMGg45jL9L1t/+AtiRZ47sakPoPN8skk9HfH+HZZ6eVCIaFxY2yjdHtO1xcOF89v8pk0nH9DU2srWW4Olx5ixTK0+tlSFukHpLJHHa7gWeefpFzLjmOnJc1O72uLDa8GEmT73P+3AKdXT6MxuIoUI1t210MDqxWVfbk0XPfuXWMhmUO1hWfe6kH68qGQIcqjX0pDf6C8qQudoby4udS/5Z6y3ARAwFUpClvok2VEK9WuEqJ26zOSESQnvN40kCHK0HoS3+Av9VPNBplYWGBhYUFkskkPp+PYDBIMBjEbFYxOiRyde7cOVKpFHv37tV4PP/X//pf/MM//ANPPPEE27dvr/xC/gLxUgjW5OQkzc3N3HPPPdx2220/v5Or4VVFjWDV8IphbW2NH/3oR9x55538+Mc/JhAIcNttt3HHHXfQ19enIVvpdJqFhQXm5+dZWlrCbrcrZMvhKO8ji8czPHV0grvvuswjD42yvp5Brxfo6Q1gdxgZvrKC1apHYPPYg/qIA5NRx/j4Km6Pma4uX1llTzhsw243KSXGlRAIWGlpdWMy6aXttAreJa/PQjBoq1jJIqtLNpuBVDrHqRPVyVVpOCgUoyfkMaTJpGfrVi/nzlXP97JYC3U0p+fZ2uElFLIxNbWuiZt4KWTP6TKxf389a2vpqtU3er3A3n2VyV64zs6WLR7W1lLY7QZeeL56CCtIREUmcuqapomJVSYnJE/SS1G3Dh9u4Oy5ebq7pcWGocGlsjDbFxvjNjY66d0eYPLaakWSqxynAtnT6yWSK8du+P16Ll5Y3ZSkHTgo+Qz/xOHCE1hnn7+oYJV6rq7GoV3Vk7yaAVeBh6yKelxCUT0tDSEtPZY60qF07Feat6X2aJUSt7EEtDmkn6tL6wJtIdj//Y+XPU/Zw7mwsMDq6ioul0shW1arlQsXLpBIJNi3b5+GXP3jP/4jX/jCF3j00UfZs+dn83S9GlhfX2d4eBiQfGJf+tKXuPHGG/H5fPh8Pj796U/zzne+k7q6Oq5evcrHP/5x1tbWOH/+fBm5rOG1ixrBquFVwcbGBg8++CB33XUX999/Py6Xi7e//e0cOXKEQ4cOacYBmUyGxcVF5ubmWFpawmq1EgqFCIfDOByOMp9GMpnlycevcf99wzz04CixWIqeXj8mkx6bzcBIlbHO1g4vKyvJsogCkLr6egpJ7tfGV5m4Vp2ktbS4SGfymvBLKULBxdJSgsuXlmlolM57chOyV1dvx2zSMzm5plx4R0eiSiQFSH13Tqd5U7LX3OKitdXN2lq6qlnb7ZaUvaHBcmWvucVFQ4ODaDSFTrd5CbfNZtAQOYNBR0+vH6vNwOVLC0RXspgtenp6Apw5XZ2kGY0CO3eFuXp1pZA5lePixUXSKbX5H3q3ebhwvvpzb2t3077Vy+hIdNN8MzVJk1EcoRpeutdOReR8fgtbO7ykUjkGVQT9pZC97TtdrCynaWryMj+fqLhcoFbJ/sLtweqJcSBUHPOWdg2qjemgrayZSwmEzSqSlNTTpcq5Gs+baFEdSx0sWtpTWKp2qWt3xnImWvXF40wmobkQJTGwLtD/x29gyzv7N31tUqkUi4uLzM/Ps7y8jCAI6HQ6ent7CQaDyu+Dr33ta3z605/m4YcfZv/+nz3u4dXAE088wY033lh2+2//9m/zT//0Txw5coTTp08TjUaJRCK86U1v4m//9m8Jh8O/gLOt4dVCjWDV8KojmUzy8MMPc9ddd3HvvfdiNpt5+9vfzh133MF1112n8VJks1nll+vCwgJms1lRtlwuVxnZymRyPH1skgd/PMIP772i+Iw6u3z4/VYmJmJMTqyze0+Iy5c2j0/YsTPI6GiMbCZPV7eXRCLO5GSKjXjxQtTb62dqavMMp779dZgtelZWUgxeXKyoULS1e1hbS5d10KmDTeNxKdurWmceSGGlOl2RyNlsUoyBXq9TvEvhsA2r1VhWNaOGP2DF4zGzvp5hyxY3q2vlZu0XK0kWBNixM0Aw5ODy0FJVJdFqM9BRQW2TDfqCTmBkeJlIg50L56svKBgMgtRdWaghqq+306Iimvm8RNL69tdX9cjJONQfIRpN4fVZmLgWU5QxNaqNIKHoGfP7LTz7zBRra9XjPrbvdHHhnHYkKvc7yib5Awe1hPCTbg8mT5T9oeLn7hpmmlVVOQsYCKpGedk8GArEZzIBjepYhpLx4gQmmigSI7UpvrSnUK1+5UXQqX4kSwNLZ9MikYL6NRwI8q5vvvRoBlEUOXfuHLFYDK/Xy9LSEn/xF39BS0sLXq+Xe+65h4ceeoj+/s0JWw01/KJQI1g1/FyRTqd5/PHHufPOO7nnnnsQRZFbb72VI0eOcMMNN2giHXK5HEtLS8zNzbG4uIjBYFCULbfbXUa2crk8zz4zxQP3XdWUUd94czOpZI6pqTXGxyp7fQ4clCINStf61UZxETh7ep5UqrJRHSgjcj6fRcr5SuYYuCDlfG3bHuDa+OqmAZndPT5mZ+P4vFbC9XZN9ISM9q0eotFURUVOPveD/Q3odHDu7EJZfYyMSIMDnVCsrJHh9Vro7PKRTGZZXNzAYNBvml7v81vwei1KmOeWNjd1dQ7m54sBny6XiUjEoVQDVYLdbqB9q5RobbMZuXJ5haUl7XM0mQS2dnoYuFC5AcDrtdDZ7cPhMPLU0Ymq2Vw6Hezrqy8bZbYWlgvmFza4OrzCgUObF3FDUbkyGnX0FAJCS7slt+9wcuF8dVUT4A03NJFKZslm8gwMSun/f+3xovcu0xcofmZKx3HqiITScNDSMV+pUf3yOnQWJvOlpOla3kizrkgY1UGjyRxYVN70wQ09ParC6aWMSNAispDRsff/+x38zS8t50kURQYGBojFYuzbtw+z2Uw+n+eRRx7hi1/8Is8++yxGo5E3velN3Hbbbbz97W//uae111DDi6FGsGr4hSGbzXLs2DG+//3vc88995BIJLj11lu57bbbuPnmmzWRDvl8nqWlJcUkr9frlW3ESuveoihy4vgsTx+b4NvfuqgoPM2y2Vq1ofVS4hMO9Us5WF3dUgxBpcqe0lyuUjidJg71R1hZSXLh/ELFUR7A7r1hhgaWykIr5eqapaUEJqOO0bHYpiGs3T0+ZmbixKIpjf9HPYZs3+ohFk1VNY6D1PWnNwj4/VZEEQYHFsuUwPqIA72++kg00uCgo8NLNifyzFOTVX1HlVSy0mDU6EqSunorV4erExWLpeA3OzNfcSMRimPKzYq4dTo4fF0j2azI2pqUxl7p/a00ggRJ1evo9OHzmUml45w+Wd3MD+XjRTln7N1TOUT3IjvdRcXq8rpAp4pgqbf5MggYVZU16jBQKCdYav9WabDohGCmSaz8uKtZcKkyskqPGwec+jzJrmYOfek/b/rcZYiiyODgICsrK+zbt0/ze+B73/seH/7wh/nhD39IJBLh3nvv5d577+X06dPMz8/jdDpf0mPUUMPPAzWCVcMvBXK5HM888ww/+MEPuOeee4hGo7z5zW/myJEj/MZv/IZmyzCfz7OysqJkbQGKsuX1ejVmehlnTs9x/w+HeeD+YUUJamp20t3t59q1VS5toqhU8tQIglRj4vFYGBuL0brF/aIkTY4QEEX1OAwGLy4Sj0uE5eChek4c33ytf9/+OuZm4jQ2uVhdS5WN8kBKcN8snb2j00tzk5OJyfWqIz+QqngWFjY0PX5mi57OTg/pdILpqTT+gI14PFs27lQj0iDJI9NT60WDflJbbhwMWrHbTZuOMqUIBC8Go75q9Y3Nrqelxc3gQPnzkouZ7XYTCPDcJl6p0hEkoIS6ymXaqVSO/QfreeG5zUeQ27Y7uXhhjeZmFw2NTpaXE2Wfuc2I/ue8PkT/Iru9RZI0vA5bVfsg6m0+tYcKysd8Y5hpVY0XxzagtUqwaKkBXh3FEMvrcOuKH75SgpUmj0UPTX98C/5bdld+cVQQRZGhoSGWlpbo6+vTkKu7776b3/u93+Ouu+7illtu0XxfNBrF4/G86PFrqOHniRrBquGXDvl8nhdeeIEf/OAH3H333czNzfGmN72JI0eO8OY3v1mzZSjncsnKVi6XU5Qtv99fkWzJZdSXBpd44P6rAPj9JkJhI6Jo5tLQMqIojdh27AxtqnDo9QJ9++tZXk4QCNiYnFit6D06dDjCc1X8O2aznp7eAMGQlePPz5St8muOUyEeQD2GHLy4wO49dS+a4L53b5iLhbiF1lY39REHC/NxhlWEZfuOIKMj0U3rg3p6/ZjNeswWA6NXV5ifL1fCtrS5WVtNV1TJHE4T3d0+DEYdc7PxqoXWUJmARRocUsBnIbrC4TTidhuYnKiuyNlsBra0eRi4uEhXlw+vz1r2vplMOnq3BTc16tsdRg4ejLC2llbCSSuhd5uDgYvlnq5gyEZbm4dEIoPDYeKZTQj633t92FtX2WIo+vGmsnoaDEUVVL01GM2AR9VWVVrQXNpjqPZovViwqJqMraDHS67qfQVdHp1eYMc9f4ZOX/6zqIYoily+fJn5+Xn6+vo0OXn3338/73//+/m///f/cuutt256nBpq+GVBjWDV8EuNfD7P6dOn+cEPfsBdd93FxMQEN998M0eOHOGtb32rxvguiiKxWExRtrLZrBJkGAgEKgYZXhpa5Bv/39Mce3KB0RFJgfEHrPT0+jEadBx9snpWltVmoLPLx9nT2hys1i0SYZmbjTNxLcau3WEl9LQSdDrYf1Dy+MhbebZCiryalFRKnS/FG65vJJnMKXlVlYJNNxtl1kcctLS6MBl1PP/czKZ+sx07g1wdXlHGhWqDvkxYKpU/l2LLFsmYvraeprc3gMGo40pJZlQk4gBBUsCqoX2rh4YGJ9FYSqOMqeFyGamPOCsqlq1b3ETqHSwtb2AyGcoy0NQwGgV27AwpcRYGg47ubh8O1QhWUjkdDA5UP2eQFNIL5xfo6vYhAkMDRUVTxv8OBEh559jhKd5eWoWTBmRepM6xAhhcF+hREaxSIrSU0+HXS4RrRdTjVUU6lKpSajJW2mk4lNDTXajRyYpgMuSxtQXo/McPbPoaiKLIlStXmJ2dpa+vT6NYP/jgg7z3ve/lW9/6Fu94xzs2PU4NNfwyoUawanjNQBRFLly4oJCty5cvc9NNN3H77bdz6623arxYoiiyurqqpMinUikCgQDhcJhAIIDBYCCVSnHmzBn0ej27du1iemqD++8b5onHx5m4tsbYaKxqVpbPb8Hvt5aFZqrhcBjZtj2ITiewtJioWNmzWe6UTifQ2eXD6zNjNOg5+uSLpaFrt9zU9S9KGvpL8Jsd7I9w/PkZfD4phiAezzA4oE1y39dXx/lz85v2711/QxO5vMjM9HrFGAKArm4fszPlBEzOOHM4jKyvp5mb29h0BFlXb8eg1ylGfVkZE5FGsBsbWVxuA3abjpmZ6ssFDoeRpmYXKytJtrRK25SDJSNYSd0KcOZ09YDZjk4PLneemekM01PV1TQ5iFUNs1lPd68fi1nP8HCUzg4v//lSinRgjl53kfioq3BAu/m3jAGfaqOwtKC5dOy3mIJAgZDN5/SE9NUJ1nJeh68wFhzbEGhVRTho8rX0AnqjSOR33kjwtuoxCqIocvXqVaampti/f7+GXD366KO8+93v5l/+5V/4zd/8zarHqKGGX0bUCFYNr0mIosilS5cUsnXhwgWuv/56br/9dt7+9rdr8nJEUWR9fV0hW4lEAo/Hw9raGl6vlx07dpSNEiuVUTucJrp7fBj0euZmi6nelRAMWnG5zRqPULjOTlubh1gsyeDAEk6nicYmJwMXK6fOgzYJXk4Un55c03QUbpbgLsNk0vFr1zcRX0+X1eaoUS3DyeE0EImYsFit2Gxm5TWphr19dVxQEbBIg4PmwihvqBDQ+VJGkB2dXhYXEgRDNvz+8lEeSCb8VCqryQ9Tw2zWs6+vDrPZwOnTs0RXKqtpLreJcNheRpo9XrOS1TU6EqWp2b2pumUwCGxpt3LlknQ+TU1OGptcrKwkGBoskuxqxng1Dl/XQHQpyR8tCBCZp81SfK1mk1BXXu0JlCtLk3oLjbnie14aNBrLgLswUizdOCz1a61kwFu473BcYKvK26XeMEQnsPdHf7bp8wO4evUqk5OT9PX1YbcXk1KPHTvGu971Lr761a/y3ve+90WPU0MNv2yoEawaXvOQ/wK+8847ueuuuzh16hSHDx/m9ttv57bbbqO+vl6zZTgxMcHly5cxGAxkMhl8Pp9SRq2OiZChLqNeXNxgZjpOMpkt1N5oTeogBZGm0rlN86s6u7zU1TtYWUoyMLBYcVzn8Zipq7NXjDSQfVNLSxtYbcayMaUapQRMrs1xubQbhZvlPMnoPxzh7BmpiFuv02m28mQcPBTh+AvVCVggYGXP3jCLiwnOn5uv2HEI0LvNz/j4atmmpNozJgIrK8mqhBEkcieKMDO9rmxTulxSeKscSOty6bHZ9cxuom7Z7Qa2dvgwGHTodELFFHujUaCl1crwlcpkLxi00b7Vg8Np5MnHr1UcY8pQOiWBL/kD5IIzdDiLUpp6DFi6+VeqLJXmXl1NGWhXpbGnRDAXfkRKg0VLx4kbCNgKG4ql3q7prJ5IwRcmGHTsuf9jVZ8fwOjoKOPj4/T19Wm8lc8++yx33HEHX/7yl/nABzYfL9ZQwy8ragSrhl8piKLItWvXuPPOO7n77rt57rnn2L9/P7fffju33347jz32GF/4whe4//77aW9vZ2NjQ1G2ZEVLNslXqqxYXk7wkx9ry6hlk7rJpCOVyjI2tkpsE6N66xYXiY2i4lJpDBmus2Mx6zVKVSk8HjPhOjvra2maW9wVN9OsNgOdnT7OnqlMwKTqGR/NzS4GB6qHg0JlAqbOCbt8eYXubv+LppgfOFjPyRPSpqTScZgtZj6BtAV5aWi5LKpCja5uH5lMnnDYRiyWYnCgvLqmpcXFRqL6huPWDi/1ETuJjeymPjmXy0RdvUOzcSnnXVntRq5eWWFtLUWk0czo1eojQXXultNpoqvHh5gXGRxY0kRfqJVEuyDwBZ8fwjO0qYzpcXTYkf5fWuZcSpLKc6+0EQ9ZEQwFglW6cVg6XlSTuQnMNKnULXSCFKQF6Mx6dt/7p1Vfi7GxMcbGxti3b58mXuH48ePcdtttfP7zn+cP//APq35/DTX8sqNGsGr4lYUoikxPT3PXXXdx1113cfToUURR5B3veAd/8zd/w5YtWzTKViKRULYRY7EYbrdbSZFXr4vLKC2j7unxc+nyMu1tHmx2I5cvL5cpK73b/ExOrFXs7wNpM23/gXpymTwnTs6SqJI8X42AhUI2JSV+enqNUMi+aQSFxaKnu8ev+InkcNC5uXVGrkoj0Jeahn74ugai0VSZMqbGocOSmb/Sbx3ZM+b2Wjhzck4TDVGK7TsCjI7ENONFn99CR0dxm7Kl1c3yUpLlKgGroDXPy6O8UqJqt+vweE1MTVY/js2mp3WLBZPJzNJipiJR1esFdu8Nc7ICkTObpffBYjFgMuk4drRYxu0WdPydz4ehbppmFWlSxynEsgJug6r4uYQkbZZ7lRNBr4qRuxQX6FJ970jWSJuh8hi3lHzpbEbyG9J9DR4rO7/74YrfNz4+zsjICPv27cPlcim3nz59mltvvZW/+Zu/4b/9t/9W8XtrqOG1ghrBquFXHvl8no997GN861vf4nd+53c4c+YMTzzxBL29vRw5coTbb7+dzs5ODdlKpVKKshWNRnG5XErWlnp9XEY8nuGJx8a574fDPPyTUeLxDDqdQE+vFO45cnWFxiYXFy9K0QjVoCZgFouB3m2SSX1wYFEpJm7d4mIjnmV+E9N3OGzDH7DicJhIpXIMVNiqc7lMNDQ6GRyo7AELhsx0dEgX/ccevVb1sQRBKiV+/jmtutXR6SUQsDE1uca1a6svqaNPHi9KJnc/VquR4eEVTVr97j0hBgeXNn0dd+4KYrUayOZExeReis28W8GQjfZ2D+l0lpWVJKMj1ZVEm91AIGDg2niRgKmT4IevrGAwCOzcFdq0RBskX9YLz8/Q3ePD7bYwPh4jNbPBp70+zPXTNKi8UeoU9cU0BFTT7Rm9hXqV56qUYKmjFhI5sKrUr8sJPZ3W4mt7JaGjwyopZereQSg3y2/55G3Yu+sxeOzojOVbuyCN6IeHh9m7dy9ut7t4jufO8ba3vY2//Mu/5M///M83fZ1qqOG1gBrBquFXHu973/t45pln+PGPf0x7ezuiKLK8vMy9997LnXfeySOPPEJHRwe33347R44coaenR2N6T6fTirK1vLyMw+FQlC21KVeGXEYtk61YLFXsuvNaGB+LMT1dvrq/d1+4KgGTR3Eer2Sc36xEuqXFRTKV0xReO50murp95PMiAwOLOB2mFy2RdjiMtLS6uXhhUSEcayVbdQaDwK49lVUZNd54k1RXpK7NKUU1D5jkGZMIhyAIvPD89KYZX9u2BxgbLapbcvm0yaTn8qUlotEUW9rcrK6mq9YMgURSTSY9q6tpOrt8UvTFRW2Zts2mw+szMDVZ3bvV1OSks0uqPirdSFTj4KFykgqwr8XD+9cNuFtm8au2+9TK02wK6jaJZSg1qs/nDYR0EuksTWMvCxYVjTQI0mtZGmA6kjbQZiqS162f+//h2tNa9bWYnJzkypUr7NmzRxMMOjAwwFve8hY++tGP8slPfrLq99dQw2sJNYJVw688nnjiCbZv304gECj7mpyddd9993HnnXfy0EMP0dTUxG233cYdd9zBzp07NWQrk8mwsLDA3Nwcy8vL2Gw2Rdmy2+0Vy6ifeWqKH957hR//6KoyMty61UsoLKk74+OrHOqXlJvNEtx37wkxNLhMJpOjpzeA3V6eldXZ5WN+Pl51Uw6koulQyEYuJ1Y0qQN4fVIMxfCV8hgKr9dCR5eXdCqLIOg4faq6KlNpvFhpo/AlxUcU1K0tbW5CYTsz02uMjWqVpV27QwwNVVe39HqB697QiCjC5aGlqpuHamO8GmpVcXJyFUHIMD1VnVyZzTq6ewKKB069kTg4sEQymUMQYP+B6iPYiF7PJzxegm2zOAuhnqVjvakkNKim2KWju1KT+2JOR6CQe7WUBr9K/SolWOpx4qqowyWoGKJBJ7VKF9D1ld/CvjVc8XlMTU1x6dIl9uzZg9frVW6/fPkyb37zm/m93/s9/uf//J8Vv7eGGl6LqBGsGmpQYW1tjQceeIA777yTBx98kGAwqJCtffv2achWNptlYWGB+fl5FhcXsVgsCtlyOp1Vy6jv/+EwP35gRFVG3UIymWVuNl41L+rAoXpOVqjQUVf25HI5LpyvPA6TUVoQLStjBgMMDS0SX5cM9maznmubGOzl8eLExBrd3T7yhY5CtWfspXT9yRuFs7NxBi5W3qaE6upWU7OLxkYHS0tJHE4j588ulBV2q9HT62diYo31QtF2R6eXQFAbffFisQ8AXq8Zq03E6bTh9doYqZBibzILtLW5GRqMVjyGVJfkx+e38vyz01V9ec16Ax/3ePA3TSlRCqUly9eSAs2W6jlXF1cFtqlGhOoNxOW8Hp9ONRLMGOkwFkn3+Aa0FMaJ8ykIqZQyx84m4kMziGnpfd/2zd/DHC6O/WTMzMwwODjI7t278fl8yu1Xr17lzW9+M+9973v53Oc+V/YzU0MNr2XUCFYNNVRBPB7nwQcf5K677uKBBx7A5XJx2223ceTIEQ4ePKhJhs/lciwuLjI/P8/CwgJGo1EZI7rd7rILRz4vcuL4DM88Ncm3/v0iU4WATKXQWRVM+lK8S3376zh3dp7mFjfBkI2pCcn3pEbv9gDXxlcVclEKvV7g0OEIBoOOgQuLLCxUHp/5A1bcbnMZGVSrO2OjUerrHZzbJC+qVN1yu810dvnIZvMMDhRHcS9F3TpwsJ6Ja6s0t7qJr6cZuFg+itu+Q0qer9bP2Nzior1dKr8+tYkq5/db0OtzzM8XSYhc6ixndS0tbRBpsDF8pfooV6eT8sJOvDCr2UgcGV7RvPa3767nNyYyhJunsBfGc6WjujmMhCmeT6liVZp7pc6yKlW/hpJ6ui2VA01L7+s+3EH7Xx1hfWCK+btP0Ppnb0VnVnX0ALOzswwMDLBr1y78fr9y+/j4OG9605t417vexZe+9KUauarhVw41gvUaQi6X42/+5m/49re/zezsLJFIhPe973186lOf0oRq/vVf/zX//M//TDQa5brrruOf/umf6OjoUI6zvLzMRz7yEe677z50Oh3vfOc7+Yd/+Aclh+aJJ57gxhtvZGVlRfFJTE9Pc8stt+D1ernvvvs05tTXAxKJBA8//DB33XUXP/zhD7FYLLz97W/njjvu4PDhwxgMxatdLpdjeXmZubk5FhYW0Ov1irLl8XgqXkgqlVHX19vZvjPI5MRaVSM6VO4nBG1lj8djflGDfWenj/kFabwoxTf4yzxj9REHer2wqQfM5TLR1OxCrxew2owMX1kp8zq9mLoll2H7/VaeeXpSMfi/1Ocvj+Lk6IvebYEXNcZv7fCwuJggupKSQmG3uImtpTVl2sGQBVHMsbhQ/XwcDiO92wIY9DrF5F4KnR527Qpx+lR5fIa6cshi0TN1dIY/drtpbJ1SDOZqggTlgZ9X8ybadUUifS1vpFlXPGc1QSsNFi3tKZxLQbigWs1mdNQZi1/z3dRL68ffVvW1mJub4+LFi+zcuVMzop+cnOSWW27hrW99K1/5ylde9+RKFMXX/Wvwq4gawXoN4bOf/Sxf+tKX+OY3v8m2bds4ceIE73//+/m7v/s7/viP/xiAL3zhC3zuc5/jm9/8Jlu2bOF//I//wfnz5xkYGFCiBt7ylrcwMzPD1772NTKZDO9///vZv38/3/nOd4BygnX16lV+4zd+g97eXr7//e9X3KJ7PSGdTvPYY49x5513cs899yAIArfeeitHjhzh+uuv14SV5vN5lpeXFZO8IAhKzpbX6920jPrK5WXuu3cYKAZUrpeoMy9F3TpwMMLs7DoNDU6WlhKaLCcZL5aq3r7VQ1Ozk+WlJOfOVlelKqlbOp1AV7cPj8fMyEiMWCxJZ6efc2erh6OqNxNNJh092wKYTXquXFlhRRW78FKe/6H+CNlsvmrPH0iZWjPT6xXHdEXPWZqpqRgL89VHsJXysurq7ZraHUGArR0OLg29eEfhs89M8cZGN+9KGGhrK45IF9IQVPmmSnOtSrcGpzERofjc1NuALxYsGhN1uGXflV4HuSLB8r91Fy1//KaK5z8/P8/58+fZuXMnwWBQuX1mZoZbbrmFG2+8ka997WsVfwZeT1CTq8nJSRobG3/BZ1TDK4UawXoN4dZbbyUcDvONb3xDue2d73wnVquVb3/724iiSCQS4WMf+xh/9mdSRUUsFiMcDvNv//ZvvPvd72ZwcJDe3l6OHz9OX18fIJWpvvWtb2VycpJIJKIhWNeuXeOWW27hpptu4pvf/KZGqalB8mEdPXqU73//+9xzzz2kUiluvfVWbr/9dm666SZNWGk+nycajSpl1KIoEgwGCYfD+Hy+iheaK5eXeeC+qzxw/7BSz+L1Wujs9uJ0ml48DbzCeC1cZycSsbC0tM7EtRR79oa5eGFx02JntXm+ucVFY4OT+YU4w1eiyn3q6u0YDLoXVbd6twUQBEGJbyiFXi+wZ2/lgmy9XqCr24/LbcJk0nP0ic37GfcfqOfUyaJ3TQqF9WMy67l8aZnoSqpqYrwa9REbiUSadBp6egIIguQ5U5M1j8dMIGirqFjJCIVsbN8ZYHk5xcDFBdKpyn6xQ4cjPFfwnO00mfiAw0FHe9EEv5TX41f5pkq3BksJ1nActpYvvAIwnjHQYiw+j1L/ljpvyxhwYAq52Lgyh5jJEXpnH40fvLHsmAsLC5w7d44dO3YQCoWU2+fm5njLW95Cf38/3/jGN1735EqNd77znbS3t/P3f//35PP52mvzK4AawXoN4bOf/Sxf//rXeeihh+js7OTs2bO86U1v4ktf+hLvec97GBkZob29ndOnT7N7927l+2644QZ2797NP/zDP/Av//IvfOxjH2NlpXgRyGazWCwWvv/973PHHXcoBOuBBx7gPe95D+95z3v4x3/8x5qE/SLI5XI8/fTT/OAHP+Cee+5hdXWVN7/5zRw5coRf//Vf15TYiqJINBpVlK1sNkswGCQUCuH3+zX+LhnjYzEeuP8qP35gmHweTp6Yxek00d3jJ5vNM3BxgZTqgv1S1J3rb2gknc4Tj2eqmsw3U7fqIw5aWl3kMnmuXVvd3BheYTNRrr2R4xtMJqn8erPNRPVz6+zyVe0orDY6laHXC9zwxiZSqRzDV1aqnntjk4211RSxmJaAyqXMZpOeubk4er2u6pICoChxcq2R3W6kq8ePTgdDA0vKGLSn187gQDFiY5/JxHucdrrbioRzCQN+VZnzUFxHt2qsV6pCqXOvSmt1JjHRqFK3SjcQ1WqX0W9nx//5IwBip8cwOCzYO+o0z3NxcZFz586xbds2wuGw5va3vvWt7Nq1i3//93+v+Bl/PeM3f/M3efzxxzl9+jQNDQ2/6NOp4RVATY54DeEv//IvWV1dpbu7G71eTy6X4+/+7u94z3veA0hmUkDzS03+v/y12dlZzV+UAAaDAZ/Pp9xHxh133MFv/uZv8pWvfOXVekq/UtDr9Vx//fVcf/31/O///b95/vnn+cEPfsAnP/lJPvjBD/KmN72JI0eOcMstt+BwOPB6vXi9Xjo7O1ldXWVubo7Lly+TTqcJBAKEw2ECgYByIWppdfNHH97LH314b8UyarvdyPad0ntrNul55kWM4f2HGzj6pCoxvEJlz959m6tbM9Pr2O1GlhYTGAw6DvVHWF/PMFjSrxgO27BYDGXqzthYjLExyXPW1uahtc3N9GR1BUweHcrEUT2Ka93ipr5eImuhkO1FexV37Azy9FNTynOTyJqFqcl1RVlrbrGzspxkba38+adSOc6enpfGoi4zVquB/sMNmo5DGRaLns4un6YzMh7PcKrgQTOZdOzcHaQubOfkCS25NAgCebQscT2Rw6+a1JdySLvDCCrSpI50yJQQrNW1DBSbajCU8B51sKigUrDdFfKulpaWOHfuHD09PZrfQ8vLy9x222309PTwzW9+8+dKro4ePcoXv/hFTp48yczMDHfffTdHjhxRvv5SfKs/D7z//e/nscce4+tf/zp/9Vd/hU6nq/1R+xpHjWC9hvC9732P//N//g/f+c532LZtG2fOnOGjH/0okUiE3/7t337FH+/222/n7rvv5tixY7zhDW94xY//qwydTkd/fz/9/f188Ytf5NSpU9x555185jOf4fd///f59V//dW6//Xbe+ta34nK5cLvduN1uOjo6WF9fZ25ujqtXr3LhwgUCgQChUIhAIIDRKDmbIw1Ofvf3d/O7v7+bhfkNfvTAVR64b5gTx2fo6vZz8uQse/aGMRh0FUuJK6lbsWhK2eizO4zccGMzKytJdPrqv+R7t/m5dq0Ye7CwIKlAHq+0EZhK5YhFk6SSuU17FV0uEyaznsceGQeKSerr62kGB5bI5UT0eoG9++oqhnECjI3GGBuN0X+4gfHxGIcOR4iuSFlbpdjbV8f5s/OaSAc1WWtpdRGJWJiZWa1IrmSEQlYsVmNZYOvWDi+hkI3JyTXm5+Ns3erb1LuWTuexWo089JMxpQHA4zEzPr6KfjFDTtBSqFKhMVdSrF06XDKo3sLSbu1SciYgVLi18LUq6ewgkaizZ8/S3d1NfX29cnssFuP222+ntbWV73znOz93m0E8HmfXrl38zu/8Du94xzvKvv73f//3/L//7/+r8a3ecsstGt/qK4nS8V8ul0Ov1/PmN7+ZAwcO8N3vfpdPfepT6PX6mvn9NY7aiPA1hKamJv7yL/+SD33oQ8ptn/nMZ/j2t7/N0NDQKz4iXF5e5uMf/zj/8R//wY9+9COuv/76n+fT/ZWEKIpcuHCB73//+9x1111cuXKFm2++mdtvv523ve1teL1ezS9UmWzNz88Tj8fx+/2KSV4mW2qsrCR48EfaMmqjUUfLFhtGA8zNZujo9FclKTL6D0d4rtAZWIxfEBgaXFKCSeXg080KmbdscZPLiYTCtopZWSCNDn0+S9WEd4/XTFe3H6fDyNEnJ0inq+dcHT7cwDMlxFFeEIivZxgYWGTvvjCnTs5tGura1u5kZiZOYiNPfcRBa6urrFA6XGfHaNAxuYniZrMZ2LEzhF4nsFhlwQDg4KF6nn+uctDoOxq9XJcX6WkoKlulW4OlI8HSWIZV9LgKIaXLOR0+ffVx4pU4dKj8Wg1/cBPLD18gMbqAtTVAz1ffV3aO0WiUU6dO0dXVpRlvra2tcdtttxEIBLjrrrsqFqj/PCEIgkbBeim+1VcLakO7TLpOnjzJDTfcwMc+9jE+/elPv2qPXcPPBzUF6zWEjY2NMuOjXq8nX1gp27JlC3V1dTz66KMKwVpdXeX5559XWun7+/uJRqOcPPn/b+/Ow6Ks9/+PP2cY9n1HUETEDXdwwyXXNFegNDMrv9axcjvtx/Rnlp02246ZmrZaXVYWoAaap46WlZIKaqmgghsiMMMi+zYw9+8P5IZh8XRqXNL347q8upj7nnvumyvh5Wd5v5MJDw8HYNeuXZhMJgYOHGh2bY1Gw7vvvotWq2XChAls27aN4cOHX+GnvLFpNBp69uxJz549Wb58OcePHycmJoZ169axcOFChg8fTmRkJJMnT8bLywsnJyecnJzo2LEjZWVlGAwGzp8/T2pqKu7u7mqtrfqdi+7u9syYGcqMmaEUF1fxzbY0Pv/sEIeSi1AU6NXbh7IyI4Mi/ElroXwCNB/dqqysUXvo2dho6d3HBy8ve3791XDZcNW5iwd6fRlFhVXqlJudne7SyFpdWLO312Fvb91quAKorKihotzIvsQsHJ2s6dXbB0VRSE3JNyuqGhHh3yxcQd2oWv3I2tBhbamurqVXL29SUvLM1qzVC+nkTOb5Mior645lZ5WqFd3rGkp7UGsyoc8p43xG6+HK0VFH+yBXszDr6+tAh+CGlkOKUrcQv7VwBVCYV2neaBCwsdNBo7pXTaNi0xGsWmMtXMrjGp0WlNZDqp1OC1w6rtHgGxWOb1Q4iqJQpS9qdn5RURGHDh2ic+fOZuGqrKyMO+64AxcXF2JjY695uGrJmTNnyMnJYcyYMeprrq6uDBw4kMTExCsWsBYsWMCOHTu49957mT9/Pi4uLtjY2BAYGMiwYcOIj4/nwQcfJCAgQEax/sIkYP2FTJ48mRdffJHAwEC6d+/OoUOHePPNN7n//vuBul/ejz76KC+88AKdOnVSh7v9/f3Vf7F169aN2267jTlz5rBu3TqMRiMLFizgrrvuwt/fv9lnajQa1q1bh5WVlRqyRowYcRWf+sal0Wjo1q0bzzzzDEuXLuXUqVPExMTwySef8NhjjzFkyBAiIyOZMmUKfn5+ODo60qFDBzp06EBFRQUGg4GsrCyOHz+Om5ubOrJVP61hY6PQrn0xy1/oRXCHLuzdk0Vc7An+8+1Zs2bU9eUTDPoyBg7yv+zC+LqpLB3f78pAo6lbAO/oaM3pU+bFMZv2A6xXWVmjLmBvH+SCr68jGg0Ul1SblV+oVxdS3NTptbJSo7q70NbOSp0GtbG1Ys9Pmc3e39igCH/2/JypjkA5OOgI7+eDptEi886dnTl7rpTqqpZHtwryK8lyKKHaaKK8zEj/AW2orTWRmppvNjLn5GRN23YupBwzn57U68vVxfQeHnaEhfuRl1+Ora22xbAHENzehYoC85IO5RU14NTwtVOTNVdNfx9bN/q6tLwG90brtxwczd/bzgGonxVtvP5Ko8HOz83sukVFRRw8eJCOHTualReoqKjgzjvvxNramq1bt16RqTZL+D3rVi2h6bRgnz59yMzM5I033mDjxo3cdtttPPbYY3To0IHnn3+eIUOGsGXLFubPny/h6i9Mpgj/QkpKSnjmmWfYvHkzBoMBf39/ZsyYwbJly9QRjPoFm++++y6FhYUMHTqUtWvX0rlzZ/U6BQUFLFiwwKzQ6KpVqy5baFRRFBYuXMhHH31EQkICI0c235otLENRFM6dO0dsbCybN29m3759DBgwgMjISCIjI2nbtq3ZD93Kykp1N2JhYSEuLi64u7uTnZ2Np6dns+bVlZU1/LDrHAnxp9Rm1DqdhsFD22KsNrW4I69eazsTGwqT2mIyKRw+bLhsUc/27V0or6gh11AXNqysNHTt5omzsw1nThei15fj6mqLr59jq9Nq9e8LC/fj0EE93UI9cXCwJj29+cjcf6sGb2OjJSzcg6LiCrIv1FBY2HIvx/btXSgvr1FHxOrZ2dW1vdHptGRdKMHRyeay963VQni/NhzYf2nNWys7CiMG++N+qJBBLtAvsGFav+kUYGqFFd3sG77fTcsyGJWGkHW2XEPQZepeNaaxtqJv/OMtHisuLiY5OZng4GDat2+vvl5ZWcn06dOpqKhgx44d6s+V60HTKcK9e/cyZMgQsrKyzNaN3XnnnWg0GjZt2mTRz4+Pj2fs2LHY2tpSUFBAdnY2zz33HPv370ev1/PAAw8watQoEhIS2L9/P5s3bzb72S3+WiRgCXEdUxSFCxcuEBcXR1xcHHv27KFv375ERUWpC4cbh62qqioyMjI4d+4ciqLg4uKijmw5OjYvhGQ01vLTj+fZ/0sWn3x8VG1GHRzshm8b84bKv6tlzwA/fj1koH1Q6y17Qjq5k59XwcWLzUesoC6s9e3ri5u7HSdO5HMhs+WCnNbWGnr28lGnL+tptRq6dvPA1dWWs2eLCerg+l9b7XTr5kJaWgk1NUqLYQ8gqIMLJSXGFqdV67m62uLXxhEbGyscHK05lWbejLvu/hpa5LTExkZL11Cvuh2FyTkMKdcQ7qzQP7BQPadZM+cmISlbsaaNpuW6Xk3XbzWtmdVpxXSK9p+mcM9Jasuq6P3VwmbXKCkpITk5maCgIIKCgtTXq6urmTFjBhcvXuTbb7/FxcWl5W/UNdI0YP2edat/RuORq61bt3LPPfcwY8YMVq1aZTaql5qayqZNm/j0008pKSmhqKgIBwcH3nnnHe666y51Ibz4a5GAJcRfhKIo6PV6tmzZQmxsLD/88AM9evQgMjKSqKgoOnXqxDfffMMnn3zCyy+/TEBAgNqMOj8/H0dHR7VlT0ujCrW1JhL3XCAh3rwZdfsgF7p09eD0qUKzwqJNDYrwZ/++upIRjanlE/Rl2NpZme06bImvrwM2NlbqKFrHEDd8fBzJzm4Ie3Z2VnTp6smvh1uvBg8weEgABn05Pr4OXGjU0Lmx0O4unDheTG0LA271PQb9A+paDl2uZZGbuy2envZm68katxzKyCgiJ7uMPmG+JLdQRLWx+jCr1Wp4IMCDzjbVdPfIU48fLdbQo1EoalocNKMCAi9NA9Yo5rsIm1Z9b1pDq8vb96q1rVpa/1NaWkpSUhKBgYEEBwerrxuNRu677z4yMzPZuXOnOvp9PWltkfuTTz7JE088AdSNzPn4+PzpRe6Nw1VSUhIHDx7klVdeobCwkLvvvpvXXnutWVeMI0eO8Ouvv/Kvf/2LQ4cO0b17d3755ZcW/3Ekrn8SsIT4C1IUhfz8fLZu3UpsbCw7d+7E19eX7Oxs5s2bx0svvWT2i9FoNJKXl4deryc/Px97e3uzsNVaM+pt8emcOVPEtzvOAOAf4ET79q4UFFRw4njDFNjvacjcq7c3JSXV+Pk5tdqyJ6CtE6ZahezsshauAO0CXWgf6IyVTsvu/1LFPSLCn8RE892STavQd+/hQmpKcbPG0I2FdHInN7ecosIqs/6OjYuKenja4eZq16xcQ2M6nYZBgwOorTGRk1Om9pxsdt9NRgrvdHSkm3MNA9s1hMNz2NKehmnMY8UaujcKXI0bNJfVoDaJBsjU2NJWaXhvjU6LrqbhGxCy7l5cgsyLh9YrKysjKSmJtm3b0rFjx4Zr1NRw//33k5aWxvfff4+Hh0er34errbS0lPT0upZTffv25c0332TkyJF4eHgQGBjIihUreOWVV8zKNPz2228WK9PwwgsvsHLlSnr37o29vT1Hjx4lIyODv/3tb7zxxhs4OztjNBrNdgWXl5ezatUq3nzzTV544QUefPBBWez+FyQBS4i/OEVRWL9+PY888gg9evQgJSWF9u3bM2XKFKKjo+nZs6fZGqyamhry8/PR6/Xk5eVhY2Oj7kZ0cXFp8Yf4oYN6tsWbN6P28XEguKM7jo46du0812rFdICwcF+OHsk1K7Hg6+dIcLAbRUWVpKbkE9jelfIyY7P1TY05O1sT0NaF46n5tGnjSFAHN4oKK0lNbSif0LiP4eWE9XOjqrKGmpq69VIt3X+Xrh5kXSilpIURt4AAJ9q1d6WirJqioirOnm29zpdOp6FXb/PpzLbtnGnXzsUsrLY0DXu3oxOdXKoZ2LZhXdzRUi09nBq+l03XZOXXaPDU1X1daAS3RhU9mp5r5WJPbXHDNGbBgp44e7s3m1ouLy8nKSmJNm3aEBISov5/Ultby0MPPcSvv/7KDz/8YNZ38HpQv6a0qVmzZrFhw4bftW71j/r3v//NpEmTWLRoEfPmzcPf35+ioiLmzJnD7t27mTBhAitXrsTV1VWdBqwf+aqpqWHQoEG4urqyc+fOP30v4uqTgCXEX9y//vUvnn32WbZs2cKoUaMoLi5m27ZtxMbGsmPHDnx9fdWwFRYW1qzIYX5+PgaDgdzcXHQ6nTqy5erq2mLYSjmWR/zX6WyLT8PDw55fErPU8gUVFUaOHTWv4t60H2BL+vT1wcHBmpKS6lZb9ri52+Ll1XKvPy8vezqGuFNeXo2Dg/Vlyx4A9OjpwrGjxWqoanh/Q8ug0FBPzmVcvkeht7c99g7WVJTXENzRzez99aytNfTo6XPZ9j/ePg70DfMlO6u02fvvc3IiyKWaQQENAatZr8EqK0JsG+Y4C2s0uF0KWHnV5lUemk4n+kztj/uwLuhj9lNy6BxdPn2Q/IJ8dWrZwcEBd3d3DAYDfn5+dO7cWf3/wmQyMX/+fH755Rd2796Nn1/LI183m/qQ9MYbb7B06VIOHDhAjx491JGq8vJyHnroITZu3Mj//d//8frrr+Ph4aG+r360atmyZXz44YckJibSrl27a/1Y4n8kZRqE+AtTFIWMjAx27txJ//79AXBxcWHGjBnMmDGDsrIyvvnmG+Li4pg8eTJubm5MmTKFyMhIBg4ciJWVlTpSYTKZ1LB1+PBhNBqNGrbc3NzUYBba3YvQ7l4sWjyIkycK6lr2xKepI0aNW+7Y2+vUgqWt6drNk1PpheookaurLV26elBtNJFytG7Uy8vLHidnm1YbKeflVVBYWEnvPr4cTy1gwMA2VBtNpDbpzwjQs5cLR34rbvb++sXorm629O/vR1FRNTXG1ndC1q8Vy7i0rqt+5K3++Y3GWtJOFhDSyfO/9lYM6eSuTsO6utnSubMHNcZaUlLy0KFBrUt1SdPYW2s0QaMyU9aNfrLXNJn+tNKaV2rX2lvj2KUNwf8vUn0tICCAgIAAampqyMrKIi0tTV0DeOjQIZycnLj11lv5xz/+wZ49eyRcYb5eLS8vDx8fH3Q6HVVVVVRV1U3JWltbU1tbi4ODAx9++CGHDx/m888/p6KiglWrVuHt7a1eJz8/nx9//BFHR0ezPqbir0NGsIS4SVRUVPDdd98RGxtLfHw8dnZ2TJkyhaioKAYPHmzWwsRkMnHx4kW1/IOiKGoQ8/DwaFbwFuqaUSfEp7MtPp1DB/UMigjgyJFcunbzwFSrkJKSR2WFeWDp0dOb06cumhUMbczRyZqwMD80WjiwP7tZFfh6rTWJdnS0pluoJwqQeiyPjiEOzcJVUz17eZN28iKVlTU4OlrTNdQTgOMpeZSV1X2+XxtHrLQaLlxoeYdj/T316u2DSQGtpq6Kff37G7vc+jUHBx0LPN3xdSmjm0NDuGy6a7BpWYbyWnC4tOksV9HhrWn4XJOtNdqqhlG5gAdH4Ht7/xY/v7KykqSkJDw9PencuTMXL15k9erVvPfee5SXl2NjY8PKlSu5++67my3YvlmtWrWKF154geTkZNLT0xk9ejRPP/00/+///T91urWqqgpbW1vmzZtHfHw81tbWjB07lhUrVuDq6oqiKBw+fJgHH3yQ559/nvHjx1/jpxJ/hAQsIW5C1dXV7Ny5k9jYWLZu3YpGo2HSpElER0dzyy23mC24VRSFwsJCtWVPbW0t3t7e+Pr64uHh0eL28QuXmlFvi09Xdxba29fVirKy0pKakkdIJ3dSU/JbbSQN5oveW2vZU9dI2ZPffr38jsKevV2oqjTh4urEyeMFzfozAvTu48Px1JbvydbWim6hXjg66jAYykk72fJoWt25Wrp09TK7J1tbK7p288TWzoqTJwoovFj1uzYHLPL3wk53kYG+DWvTmta9Ol9tRTubhq9rTKC7lIGb1r2yC/Ki8lw+9cOKgY+MxWt872afW1VVRVJSEu7u7nTr1k0dnVEUhcWLF/PZZ58RFRXFrl27MBgM3HbbbTz11FPNOkLc6BqPXKWkpHD77bczYsQInnjiCTp16sSDDz7Ip59+ypo1a5gxY4YaRMvLy5k9eza9evXi/PnzfP7557z//vtMmzYNqAu39W17xF9T83+GCnENXLhwgXvuuQdPT0/s7e3p2bMnSUlJ6nFFUVi2bBlt2rTB3t6eMWPGkJaWZnaNgoICZs6ciYuLC25ubjzwwAOUljaMMPzwww9oNBoKCwvV17KysujZsye33HILRUUt7+q6EdnY2DB+/Hjef/99srKy+Pzzz7GxseHBBx8kODiYhx9+mB07dlBVVYVGo8Hd3Z2uXbsybNgw+vbti42NDcePH2f37t0cOXIEvV5PbaM6BwEBzsx5qA9bEqZy+Oj9rHh9JP36t+G3X3M5sD+b0O5eaDQaevfxxdW15RYq7du7UF1tUncU1rfsObA/h8rKWnr18WHQYH+69/T6r+Gqe09njvxazMkTpSTtz6GiooaevbwZFOGPp1fdL7y+Yb6kpuS1GviqqmrJzS0jPb2QM6eL6NnTm4ER/nh5mY/c2NlZ0aWFwFdVVcuvhw3s/yWbkuJqxtzaHsWk4Ovb+vRPr97eVJUZaTrHamoy72fVqBm0SWkIV9BQlL2ezt2RPl8/RrsFY7Dv5Iu1n2sLz1pFcnIyrq6uzcLV8uXLiYmJITExkffff59Tp06xZ88eevbsSU1N662TblT135vffvsNvV6Pg4MD8+fPp1OnTgA88cQTjB49mnnz5rFixQoOHz5MQUEBn376KT/99BPdunVj7dq1+Pj48Mknn6jXtbOzk3D1FycjWOKau3jxIn379mXkyJHMnTsXb29v0tLS6Nixo7oVfMWKFbz88stmW6mPHDlitpV6/PjxZGdns379eoxGI7Nnz6Z///589tlnQPMK9adOneLWW28lNDSUr776SqY4qFv0/vPPPxMTE8OWLVsoKSlh/PjxREVFMWbMGLPvkaIolJSUqCNblZWVeHl54evri5eXl9mUY72Cggp2fneWr7ems/v7c1RXm9DptISGeuLgaK32R+wY4sbFgkoKWmifU8/Z2ZqAAGfS0i7SLdQTJycbTqWbt+wBCO3hRMrR1qfytFoNI0cHUlFew6n0i2ph0abatXOmqqoWg8H8uEZTt47Mzc2WrKxSnJ1tOXokt9XPA/PdgvW1tjw97c2q6Pfq7c3x4wUssHXC2a2Ygb4N34umOwENtVb4WNVFqSoT2DYKWOnlGkIajWC5DOxIyPLbW7236upqkpKScHZ2pkePHmYbHV5++WXeffdddu/eTdeuXS/7jDeT9PR0OnfujIeHBx06dODAgQNmx1NTU3nzzTf54IMPsLGxwdbWltLSUqZMmcLmzZsBGDNmDBcuXODIkSMt/t0Rfz0SsMQ19/TTT7Nnzx5++umnFo//no73qamphIaGcuDAAfr16wfAjh07mDBhApmZmfj7+5sFrIyMDMaNG8eoUaP4+OOP5QdaC0wmE7/88osatnJzcxk3bhxRUVGMHTvWrFipoiiUlpZiMBjQ6/VUVFTg4eGBr68v3t7eZlOO9YqLq/ju32dI+DqdH77PoKKiBq1Ww9Bb2qKY4OSJ/FbDjpubLV7ezXcUNg47Z88W4e6uIeVY6+EK6qrPH0rWqzv3OndpHnZaa5HTmL2DjuBgNyora/DxcSQrq5RzZ5uPig4eHNBiU+p6HYJd6djRnfMZxZw4UcA/XN1wcCtkgE9D7arUUg3dGhUL1VeB76WBwHKTBgdtoxGtJmuu3G7pQvCSKS1+ttFoJCkpCUdHR3r06GG21u71119n1apVaoFb0SA/P58PP/yQ1atXo9friY+PZ/To0c3WKu7YsYM9e/ZQXV1Nhw4dePjhh4G6qcW77rqLkJAQNm3ahE6nk5pXNwAJWOKaCw0NZdy4cWRmZrJ7924CAgKYN28ec+bMAX5fO4sPP/yQJ554gosXG37h1tTUYGdnx1dffUV0dLQasLZt28bMmTOZOXMmb7/9tvwg+x1MJhPJycnExsYSFxdHZmYmt956K5GRkUyYMKFZS5SysjJ1ZKu0tBQPDw91kXx930zz843s/M9Zfvw+g2//fQaDoRyNpi7seHjac+5sEVmXFpR7etnj6mJ72aKeWi106epEaamJtm3duJBZ2qxlD8CAgW1IOpDTrPp8vQ7BrgQFuZCXX8mRX1sflXJw0BHUwY2UY3lmrzcUNi0nPe3ifw1X0DByVV1VS9u2zjxca4et+0W6OzYUXz1VZUXHRmUZ8qrA61LAalr3yjbAHWNhOaayuoDmcWsPgp5ovmjaaDSSnJysTtE3Dgdvv/02K1asYNeuXWZ/B0UDg8HAV199xdKlS+nfvz/vv/8+gYGB//V9x48f57333uPtt98mNjaWyZMnX4W7FVeD/LNdXHOnT5/mnXfe4fHHH2fJkiUcOHCAv//979jY2DBr1qzf1fE+JycHHx8fs+M6nQ4PDw/1nHrR0dFMnz6d1atXX8GnurFotVr69+9P//79eemllzhy5AgxMTG88cYbzJs3j9GjRzNlyhQmTZqEm5sbjo6OBAcHExwcTHl5OQaDgaysLI4fP467e0MRS1vbulTg6GjNlMhOTInsRGVlDbu/zyD+63S++/cZtQhnSCd3/P0dKSszkpzUetkDKyvoGOJIakpdIDufcamXYJArbQKcMOSUcepUIQMHtWH/vuzLlpDQajQcPpTLxYuVtGvnTNt2Ls2q0Ds66mgf5NosXAFknCtWyzgMH9GOqupauoV6crxRYdTGGocrgMzMEqrddJjsjNBol6CuyepZ60ZfG5uUZVBMCn1i/07FuTz0X+3HqXtAs881Go0cPHgQW1vbZuFq/fr1vPzyy/znP/+RcEVDjauysjLKy8vRaDR4eXnh4+PDXXfdhUajYdGiRTz00EO89957tG3bFmhYDN94UfymTZt4/vnnycrKYvXq1RKubjASsMQ1ZzKZ6NevHy+99BJQ187i6NGjrFu3jlmzZln88yIjI9m8eTM//fQTw4YNs/j1b3RarZbevXvTu3dvnn/+eVJTU4mJieGdd95h4cKFDB8+nKioKCZNmoSXlxcODg5qU+DKykoMBgM5OTmcOHECV1dXtdZW/Vo6Ozsd48YHM258sNqMelv8KZKTcjiVXsiFC6VqWGraskan09Ah2J6TJ5q32jl7toizl6bsRowKpKqylk6dPVps2QMQ0smN3NwKigrrRn7Ony9Rpwx9/Rzp0MGVsjIjNTUmUo613qMQ6tZcNW7t4+llT0iIOxUVdYVJa2qUZuFKfSbqyjyYqVWg0ShV416DTRe1a3V1uzzt23sR9OSEZvdWU1PDoUOHsLa2pnfv3mbh6sMPP+TZZ5/l22+/Vafeb2b14WrPnj3885//5LfffsPJyYlOnTqxZs0agoKCuPfee7G2tubJJ59k9uzZfPDBBwQGBqqhqv6/NTU1eHt7M2TIEMaPH090dPS1fDRxBUjAEtdcmzZtCA0NNXutW7duxMbGAqgFDPV6PW3atFHP0ev16r+o/fz8MBjMd23V1NRQUFDQrADi+vXr+cc//sH48ePZvn07t9xyi6Uf6aah0WgIDQ1l2bJlPPPMM6SnpxMTE8OGDRt49NFHGTJkCFFRUUyZMkUNUYGBgQQGBlJVVaXW2UpLS8PZ2Vlt2VNfWNHa2opRo4MYNTqoWTPq+vIGdS1nnMnLK0NRjKSdbH2dFEDEYH9+2JWhfu3r61DXsqe4itSUupGlTp3dMejLKSqqavEa+pwyysuq8Q9wJje3nIGD/M3CkvnnNW9/k59XQX59YVNXW/oPbEPhxcrmQQrQaTSgMb+m0qR5om2jShk+TjowNuzm01g3L6NRr7a2lkOHDmFlZdUsXH366acsXryY7du3M2jQoFavcTPRarXs27ePsWPH0rdvX+69914qKir4+uuvCQ8PZ8eOHfTv35+77roLKysrnnrqKWbPns369esJCQkxu5ZOp2PUqFEMHjzYIj0PxfVHApa45oYMGcKJEyfMXjt58iTt27cHoEOHDvj5+bFz5041UBUXF7Nv3z7mzp0LQEREBIWFhSQnJxMeHg7Arl27MJlMzeryaDQa3n33XbRaLRMmTGDbtm0MHz78Cj/ljU+j0dCpUycWL17M008/zdmzZ4mNjeWrr77iySefZNCgQURGRhIZGUlAQAC2tra0a9eOdu3aUV1dTW5uLnq9nvT0dJycnNSRrfrijFZWWobe0o6ht7TjpRUjOLA/+1J/xFMcTM7BP8CWkhITgwb7U1xYZdafsF5Ldaf0+nJ1Mb2nlz19+vhQVFRlNjLWlIuLDX5tnNTpy335l6rYX6pCbzSaSE3Jo2+Yb7Nw1VT7IBd+3H2e6qpaHBx0hPerK6yaeqyuMKkO0NqYJy+rJkGs8QiWtb01Oh9nqrIuggIam5YDVn240mg09OnTx6ye2aZNm3jiiSf4+uuvZZS3kaKiIp566imGDx/Oq6++qi72P3r0KAcPHqSsrAxFUXB2dubOO+/E2tqaWbNm8frrr7Nu3boWrynh6sYli9zFNXfgwAEGDx7M8uXLufPOO9m/fz9z5szh3XffZebMmQC/q+P9+PHj0ev1rFu3Ti3T0K9fv1bLNCiKwvz58/n444/Ztm0bI0aMuFbfghuaoihcuHCBuLg4YmNj2bt3L2FhYURFRREZGUn79u3NNhoYjUZyc3PVXnj29vbqyJaTk1OzTQklJSV89eVPpBxV+PmnPM6eqZsG9PKyJ6STO6Ul1aSk5DEoIoC9/6WoZ9dunpw/X9d/sKWWPVAXrnz9HC9baBRgyLC2VFbUgKYuLLVUrb61aUGoL2zqyf+dN2Hln09H24YyDVmV4H/p97LRZL4GS+toS5/Yv2OqriE34RBAs0rttbW1HD58GJPJRFhYmFm42rx5Mw899BBxcXGMHTv2ss94s8nNzaV3794sWbKEBQsWADB79mzi4uLYuHEjo0ePxt7eXm3cXFRURGJiIqNHj25xJ624sUnAEteFhIQEFi9eTFpaGh06dODxxx9XdxECv6vjfUFBAQsWLCA+Ph6tVssdd9zBqlWr1HICTQNW/XUXLlzIRx99REJCAiNHjryqz32zURSFnJwctmzZQmxsLLt376Znz55ERkYSFRVFSEiIWYCqqakhLy8PvV5PXl4ednZ26siWs7MzxcXFHDp0iPbt29OhQwcAjh3NJSG+rop8/fqqYcPbUVVZQ1VVLSnHcjEam//YC+3uybmzxZSVNW/u7OhkTbdunmg0dTsef8+aq8YjV/VhycbGihPHCygqqrpsuKrn6WXPs4oDRi893VwazjNUgU99WYZGbXEArFzs6P3lwlavaTKZOHz4MDU1NYSFhZmVKElISGD27Nl8+eWXTJw48bLPeDNKT08nNDSULVu2MGHCBObMmcPnn3/OJ598wqRJk7CxsUGv1/Pkk0/y9ttvqz9nADV0iZuHBCwhxDWhKAr5+fls3bqVmJgYdu3aRZcuXdT+iI0riEPdL6i8vDwMBgO5ublYWVlhNBpp27YtXbp0abHcRtrJAn78IYPPP0vh6JG6XX7OzjZ07eZJbY2prj9iZS3de3hx+lQhFRWtVyJ3c7fF09OeC5mlasueEy203ImI8CcxMavV6+h0Wm4Z0Y6K8hpOnixQ12I15ellj7OjDU+WWmP0zqGLc0PAKjZpcLlU68qk1aJttCZL5+5Ir8/ntXhNk8nEr7/+SnV1NWFhYWajKjt27ODee+/l008/5fbbWy9EerOqb4Y+bNgwRo0ahdFoZOPGjXz00UdERkZiZ2eHyWTixRdfZNOmTXz55ZfN1paKm4sELCHENVff7/Drr78mNjaW7777jvbt2xMZGUl0dHSzopcZGRmkpaXh5OREeXk5VlZWaukHd3f3FsNW02bUilJXv2rwkABKS4389quh1abT7h52uLvZNau9ZW2tJbS7F3Z2Ok6eLKBLFw9+uUy4AvNpQa1WQ9duHri62nLmTBE5l9oCeXja4eJsS9bZIt709MLkk02IU0OIKjaCy6VspLG2wqGLH+UnclCMtVh7O9Pz04ebfa7JZOLIkSNUVFQQHh5uFq527tzJjBkz+OCDD5g+ffpl7/9m0Hi0qXFZBYDly5ezfPlyANasWaOuA1UUhR9//JHHH3+cLl26sGHDhhZrvombhwQsIcR1p7i4mISEBGJjY9mxYwd+fn7qNOL58+dZsGABO3bsoGfPnphMJi5evKgWNtVoNGozand392bVtAGyLpSwLeEUB/Zn892/z1BRUYOtnRWhoV7odFpOHM9XR6Y8PO3qAtDpy/eqjBgcQElJVaste+Dya66gbvein58jFRU1JB3IwV6j4TUPTzS+2XRwbAhYjacFNVZa+m57AoCipNNUns3Dd+oAs+uaTCaOHj1KWVkZ4eHhZr/4f/zxR6ZOncq6deu45557LvuMN4P6cJWdnc0bb7xBTk4OI0aMYOzYsWrh0Pnz56tlSWbOnEn//v359NNPeeeddzAYDOzbtw8vL69m4UzcXCRgCSGua6WlpXzzzTfExcWxdetWKisrGTZsGMuWLWPAgAFm61pMJhOFhYVqyx5FUfD29sbHxwdPT88Ww5ZBX8Y320+zLT6dvXsuUFNjUkemHB2sKSqu4tjR5kVEGxsU4W82cqXRQJeunri723L2bDHZWaW/a82Vm7st7u52nDldRFCQKx18HbkjvRprvyzaNeonqAD1v7Y11lb0jX+81WsqisLRo0cpKSmhX79+ZuFq7969REdH89Zbb3H//fdf9hlvJgaDgX79+lFUVIS9vT15eXmMGTOGxYsXM3z4cAoLC3nuuedYtWoVGo0GKysrHB0dCQkJYcuWLQQEBMiaKyEBSwjx17BlyxZmzpzJvHnz0Ov1JCQkYG9vz5QpU4iMjGTw4MFmC7YVRaGoqEgd2aqpqVGbUXt6erb4y6+goIId35xmW/wpUlPy0Om0XMgsUZtJp6ddJK/Jmqmm4aolw0e2o8aokHm+mHPnmrfsgbpw5eFubzYN6a7V8k93D5za5eBj3XIw09rq6LP1sRaPKYpCSkoKRUVFhIeHq5XzoW737pQpU1ixYoXaE+9mVlNTg06nw2Qy8eqrr5KQkMArr7xC586dSUpKYvr06XTs2JEVK1Ywbtw4AL777jvOnTtHdnY2AwYMoH///nh4eEi4EoAELCHEX0B9uPrss8+IjIwEoKqqip07dxIbG8vWrVuxsrJi0qRJREdHM2zYMLM1RoqiUFxcrI5sVVdXq+1NvLy8Wmz2XVJcxbdNmlE3biZ95kwR7YNc2fc/rLmCSy17/J0wGMo4lV4I1DWv9vC0b1Z7y0erZZm7B04BWfjYNvyodhvameJD5zCVVaG1t6HP5keafa6iKKSmpnLx4kX69etnFq4OHTrEpEmTWL58OX//+98v/82/gZ09exYbGxv8/f2BupIf27dv54svviAwMJCVK1eqU3zHjh1j6NCh+Pv78/LLLzNlSssNs+urvQshAUsIcd1LS0vj9OnT6shBU0ajkd27dxMTE8OWLVswGo1MnDiR6OhoRowYYRYuFEWhtLRUHdmqqKjA09MTX19fvLy8WqxXVN+Melt8Ov/59ixlZUYGDvKnoKACLy8HMs8Xq210Gvtv04Jt2zrTIdgVkwJ7fspsdtzfyoolbu64tb2AR6P10mE7ngKg4lweRftP4zfNfM2VoigcP36c/Px8+vXrZ1bM8rfffmPChAksWbKEJ598ssX7uhkcPnyYsLAwVq5cyfz587GysmLu3LmsX7+e4OBgXn75ZaZNm0ZtbS2KoqDT6Th+/DhDhw7F29ubFStWtBqyhAAJWEKIG0xtbS0//fSTGrZKS0uZMGECUVFRaiHIxkpLS9WRrbKyMjw9PfHx8cHb27vFXWCVlTXs/TmTuNiTfPfvM2o7neBgN3zbOJKdVcLZM8W/a82Vq6stXt72nEovxNfPkeAOrmYtewKtdPzDzY32IdlY1Zdi0EDYN0+1ek1FUTh58qS6jqjx86akpDB+/Hgee+wxlixZ8r98W28oKSkpDBkyhIiICF577TW6d+8O1FVqnzt3Ll988QWjR49mw4YNBATUNceun0I8ffo0w4cPp7Kykg8//FAaNItWyTimEFfZK6+8gkaj4dFHH1Vfq6ysZP78+Xh6euLk5MQdd9yBXq83e19GRgYTJ07EwcEBHx8fnnrqKWpqGsoKbNiwwaywIUBqairt2rVj2rRpVFeb12u6UVlZWTFixAhWr17NuXPn2LZtG35+fixatIigoCBmzZpFXFwcZWV1JRGcnJwIDg4mIiKCwYMH4+bmRmZmJj/++CPJyclkZmZSVdXQk9DOTseoMUGsfmcsR0/8jc++nMLMe7tTWFRJ4p4LnD1TzLBb2uLsbENgoHOr9+nqaou3j4M6TajPKSMxMYuUY/m4e9gxcJA/XULcAAVtbaPeg5fZlaYoCmlpaej1esLDw83C1cmTJ5k0aRLz5s275uHqueeeQ6PRmP3p2rXrVfnstLQ0hgwZwoABA3j99dfVcAXg6urKxx9/zF133cWuXbt4//331b+HOp0Oo9FIcHAwP//8M66urs36CwrRmIxgCXEVHThwgDvvvBMXFxdGjhzJypUrAZg7dy7btm1jw4YNuLq6smDBArRaLXv27AHqRmX69OmDn58fr732GtnZ2dx3333MmTOHl156CUBtsFxYWKh+1vjx44mOjmb9+vU3/boQk8lEUlISsbGxbN68mQsXLnDrrbcSGRnJ+PHjcXFxMTu/oqJCHdkqLi7G1dVVbdnTUv+4+mbUO3eeJX5rOpmXpgz9A5xo396VixcrOJ5aV1nexcUGH19H0tMu327nnds8aWvIxntCT4r3pVNTWG5WlqExRVFIT08nOzubfv36qQ2zAU6dOsVtt93Gfffdx0svvXTNSwc899xzxMTE8J///Ed9TafT4eXldUU/9+zZswwcOJAePXrw1ltvqb0EAX7++We++eYbXnzxRSorK5k9ezYxMTEsXbqUhx56SG0abzQasba2NlsUf7P/3RItk4AlxFVSWlpKWFgYa9eu5YUXXqBPnz6sXLmSoqIivL29+eyzz5g6dSoAx48fp1u3biQmJjJo0CC++eYbJk2aRFZWFr6+vgCsW7eORYsWkZubi42NjVnA2rVrF5GRkcybN48VK1Zcy8e+LplMJn777TdiYmKIi4vj9OnTjB49msjISCZOnIibm5tZCKmsrMRgMGAwGCgsLMTFxUVt2dN0yrHu+kpDM+r4dC5cKAXAx8eBTl08sLLS8POP52lUgL2Zt6b60encOQD6bHsCrZWW6rwSCr5PbbbmCupCVGZmJv369VMbZAOcO3eOsWPHMm3aNN54441rHq6gLmBt2bKFw4cPX7XPLCwspGvXrtjb27NlyxZ69+6tHktOTmbUqFFERETw5Zdf4uLiQnV1NQ888ACfffYZS5YsYe7cuepieGhegFSIpiR2C3GVzJ8/n4kTJzJmzBiz15OTkzEajWavd+3alcDAQBITEwFITEykZ8+eargCGDduHMXFxRw7dszseps3b2bixIksXbpUwlUrtFotffr04YUXXuDYsWMkJyczYMAA1q5dS4cOHYiOjmbDhg3k5eWhKAp2dnYEBgbSr18/brnlFvz9/SkoKGDPnj388ssvnDlzRp1yrLu+hoGD/Hn+xVtI+nU227+9k/kLw/HytsegL+PHH87j5l43Ddirtzc6nfkv6jfv8FXDlaKA1qruR7WNl3OL4er06dOcP3+e8PBws3CVmZnJ+PHjiYyMvG7CVb20tDT8/f0JDg5m5syZZGRkXNHPy83NpWvXruTl5ZGSkqK+/ttvvzF27FhGjx7NBx98oI5k2tjY8NFHHzFr1ixeffVVXn31VTIzGzYiXE/fS3F9ar43WQhhcV988QUHDx7kwIEDzY7l5ORgY2PTbP2Ur68vOTk56jmNw1X98fpj9UpLS5k2bRpLlixh0aJFFn6KG5NGo6F79+50796dZcuWkZaWRkxMDB999BGPPPIIQ4cOJSoqismTJ+Pr64uNjQ1t27albdu2GI1GcnNz0ev1nDp1CkdHR3Vky9HRUV1fFBbuR1i4H888N8SsGfW+X+pKPLi62tKlqwdGYy13B2npmnFOvT9Fufwv8rNnz5KRkUF4eLja2BwgOzubCRMmMHbsWLUg5vVi4MCBbNiwgS5dupCdnc3y5csZNmwYR48exdm59XVrf0anTp149913+fvf/87f/vY3bGxs6Nq1K2PGjCEiIoKVK1eqC9rrp/10Oh3vvvsuGo2GVatWsWDBgityb+LGJCNYQlxh58+f55FHHmHjxo0trt2xJHt7e2699Vbee+89UlNTr+hn3Yg0Gg2dO3dmyZIl7N+/nxMnTjBhwgQ2bdpE586due2221i7di2ZmZkoioK1tTX+/v707duXESNGEBQURGlpKfv27WPv3r2kp6dTXFxM45UY3Xt4s2jxIH7cew8/7r2HRYsH0S7Qmf37shnv5oxLsoka/87YhrQFnRUKrQejc+fOcebMGcLCwsyCiV6vZ+LEiQwbNox169Zdd2uExo8fz7Rp0+jVqxfjxo1j+/btFBYW8uWXX17Rz+3cuTOrV69mxIgR3H333QwYMIDw8HDWrl2rtsFRFEX9fhkMBlJSUnjrrbdITU2VRe3if3J9/a0T4gaUnJyMwWAgLCwMnU6HTqdj9+7drFq1Cp1Oh6+vL9XV1eri9Hp6vV5dWOvn59dsV2H91/XnQN0Oui1bthAWFsbIkSMlZP0JGo2G4OBgnnrqKfbs2cOZM2eYOnUq8fHxhIaGMnr0aN566y3Onj2r1klq06YNvXv3ZsSIEYSEhFBeXk5SUhJ79uzh5MmTFBUVmYWtzl08eOzJAfznh7vZnzyLceM64BTsTsbPZaR+q6DpNwTvmSNavL/z589z+vRpwsLCzBbo5+bmMmnSJMLDw3n//fevu3DVEjc3Nzp37kx6evoV/6yQkBBWr17N9OnTqaioYOjQoerIVeN1VdnZ2SxbtoyZM2dy8eJFunTpcsXvTdxgFCHEFVVcXKwcOXLE7E+/fv2Ue+65Rzly5IhSWFioWFtbKzExMep7jh8/rgBKYmKioiiKsn37dkWr1Sp6vV49Z/369YqLi4tSWVmpKIqifPTRR4qrq6uiKIpSWVmpTJo0SfH19VWOHTt29R72JmAymZSsrCxlzZo1yqhRoxSdTqeEhYUpy5cvVw4fPqyUlpYqZWVl6p/i4mLlzJkzyr59+5SEhARlx44dysGDB5XMzMxm59b/yU03KIfXJiu/vX+4xeMnTpxQEhISlAsXLpi9fv78eaVXr17KtGnTFKPReK2/Vb9bSUmJ4u7urrz11ltX7TNPnz6tTJ06VbG2tlbeeecdpaqqSj2WnZ2tPPXUU4pGo1Hee++9q3ZP4sYiAUuIa2D48OHKI488on798MMPK4GBgcquXbuUpKQkJSIiQomIiFCP19TUKD169FDGjh2rHD58WNmxY4fi7e2tLF68WD2nccBSFEWpqqpSpkyZovj4+ChHjx69Go910zGZTIrBYFDeffddZdy4cYqNjY3Ss2dPZenSpUpSUlKzAFVSUqKcO3dO2b9/v7Jt2zZl+/btSlJSkpKRkaGUlJS0GKaa/jl58qQSHx/fLFxduHBB6du3rxIZGalUV1df62/NZT3xxBPKDz/8oJw5c0bZs2ePMmbMGMXLy0sxGAxX9T7Onz+vTJ8+XbGyslLDncFgUBYvXqxoNBrlgw8+UM81mUxX9d7EX58schfiOvCvf/0LrVbLHXfcQVVVFePGjWPt2rXqcSsrKxISEpg7dy4RERE4Ojoya9Ysnn/++VavaWNjQ0xMDHfeeScjR45k165dZnV/xJ+n0Wjw9vZmzpw5/O1vf+PixYt8/fXXxMXF8frrrxMUFERkZCTR0dF0794drVaLl5cXXl5emEwmLl68iMFg4OjRoyiKgre3N76+vnh4eLQ4tZeVlcWJEyfo06eP2aaIkpISoqOjadOmDZs2bWqx3c/1JDMzkxkzZpCfn4+3tzdDhw7ll19+wdvb+6reR9u2bXnzzTfR6XQ89thjFBYWYjQaeeWVV1izZg33338/ICUZxB8jdbCEEOIKKCoqIiEhgbi4OHbs2EGbNm2IjIwkKiqKvn37mgUoRVEoLCxU+yPW1tbi7e2Nj48Pnp6eWFlZkZOTQ0pKCr1798bT01N9b1lZGVFRUTg4OBAfH3/FN1LciHJycli6dCkffvghACtXrlSbYEu4En+UBCwhhLjCSktL2b59O3FxcWzfvh0PDw+mTJlCVFQU/fv3x8rKSj1XURSKiorUwqbV1dU4OTlRUlJCjx49zMp1lJeXM3XqVLRaLQkJCWbV28X/Rq/Xs3TpUsLDw3n44YcBpEq7+FMkYAkhxFVUXl7Ot99+S2xsLAkJCTg6OjJ58mSioqKIiIhAp2tYuaEoCmfPniU9PR1bW1uMRiMHDx7E1dWVyZMn8/DDD1NZWck333xjVgNL/DEVFRVqZX4JV+LPkoAlhBDXSGVlJTt37iQ2Npavv/4aKysrJk+eTHR0NEOHDiU2NpY1a9YQExODj48PZWVlrF69mk8//ZRz587h6urKyy+/zPTp03F3d7/WjyOEaEQClhBCXAeMRiM//PADMTExbN26lfLycsrLy3nooYd48cUXsbGxUc+79957SU9PZ+rUqWzbto0jR44watQoli5dytChQ6/xkwghQAKWEEJcd7799lsiIyMZOnQoqamplJaWMnHiRCZNmsSXX37JmTNn2LVrFx4eHgCcOXOG2NhYbrnlFgYMaN6rUAhx9UnAEkKI68ju3buZNGkSa9eu5d5776W2tpbExERiY2P55JNPMBqNnDp16qqXNBBC/G8kYAkhxHXk7bffxtHRUa3B1JjRaOT8+fMEBwdfgzsTQvwvJGAJYQFr165l/vz5DBgwgH379l3r2xFCCHGNyR5UISxg48aNBAUFsX///qvSsPZ68/LLL9O/f3+cnZ3x8fEhKiqKEydOmJ1TWVnJ/Pnz8fT0xMnJiTvuuKNZA+uMjAwmTpyIg4MDPj4+PPXUU9TU1KjHN2zYYFbBHCA1NZV27doxbdo0qqurr9gzCiHE/0IClhB/0pkzZ9i7dy9vvvkm3t7ebNy48Vrf0lW3e/du5s+fzy+//MJ3332H0Whk7NixlJWVqec89thjxMfH89VXX7F7926ysrK4/fbb1eO1tbVMnDiR6upq9u7dy8cff8yGDRtYtmxZq5974MABhg0bxm233camTZvUnXZCCHHNXb22h0LcmP75z38q7u7uSlVVlTJ37lylU6dOzc7Jy8tT7rnnHsXZ2VlxdXVV7rvvPuXw4cMKoHz00Udm56ampip33HGH4u7urtja2irh4eHK1q1br9LTWIbBYFAAZffu3YqiKEphYaFibW2tfPXVV+o5qampCqAkJiYqiqIo27dvV7RarZKTk6Oe88477yguLi5KVVWVoijmDa137typODk5Kf/4xz+u0lMJIcTvJyNYQvxJGzdu5Pbbb8fGxoYZM2aQlpbGgQMH1OMmk4nJkyfz+eefM2vWLF588UWys7OZNWtWs2sdO3aMQYMGkZqaytNPP80bb7yBo6MjUVFRbN68+Wo+1p9SVFQEoJYRSE5Oxmg0MmbMGPWcrl27EhgYSGJiIgCJiYn07NnTrBXMuHHjKC4u5tixY2bX37x5MxMnTmTp0qWsWLHiSj+OEEL8z3T//RQhRGuSk5M5fvw4b7/9NgBDhw6lbdu2bNy4kf79+wOwZcsWEhMTWblyJY888ggAc+fO5dZbb212vUceeYTAwEAOHDiAra0tAPPmzWPo0KEsWrSI6Ojoq/Rkf5zJZOLRRx9lyJAh9OjRA6hrpmtjY9Ns/ZSvry85OTnqOY3DVf3x+mP1SktLmTZtGkuWLGHRokVX8EmEEOKPkxEsIf6EjRs34uvry8iRIwHQaDRMnz6dL774gtraWgB27NiBtbU1c+bMUd+n1WqZP3++2bUKCgrYtWsXd955JyUlJeTl5ZGXl0d+fj7jxo0jLS2NCxcuXL2H+4Pmz5/P0aNH+eKLL67I9e3t7bn11lt57733SE1NvSKfIYQQf5YELCH+oNraWr744gtGjhzJmTNnSE9PJz09nYEDB6LX69m5cycA586do02bNjg4OJi9PyQkxOzr9PR0FEXhmWeewdvb2+zPs88+C4DBYLg6D/cHLViwgISEBL7//nvatm2rvu7n50d1dTWFhYVm5+v1evz8/NRzmu4qrP+6/hwAKysrtmzZQlhYGCNHjpSQJYS4LskUoRB/0K5du8jOzuaLL75ocbRm48aNjB079ndfz2QyAfDkk08ybty4Fs9pGsquF4qisHDhQjZv3swPP/xAhw4dzI6Hh4djbW3Nzp07ueOOOwA4ceIEGRkZREREABAREcGLL76IwWDAx8cHgO+++w4XFxdCQ0PNrmdra0tcXBxTp05l5MiR7Nq1q9k5QghxLUnAEuIP2rhxIz4+PqxZs6bZsbi4ODZv3sy6deto374933//PeXl5WajWE3rZdVX57a2tjZbDP5XMH/+fD777DO2bt2Ks7OzumbK1dUVe3t7XF1deeCBB3j88cfx8PDAxcWFhQsXEhERwaBBgwAYO3YsoaGh3Hvvvbz66qvk5OSwdOlS5s+fr65Ha8zW1pbY2FimTZumhqzu3btf1ecWQohWXettjEL8FZWXlyvOzs7K/fff3+LxPXv2KIDyxRdfKDExMQqgrFy5Uj1eW1urjBo1qlmZhhEjRigeHh5KVlZWs2saDAaLP4elAC3+afxsFRUVyrx58xR3d3fFwcFBiY6OVrKzs82uc/bsWWX8+PGKvb294uXlpTzxxBOK0WhUjzcu01CvurpaiYqKUry9vZUjR45cyccUQojfTVrlCPEHbNq0ibvuuostW7YQGRnZ7LjJZMLPz49BgwaxefNmBg8eTHJyMnPnzqVr1658/fXXGAwGDh8+zIYNG9SSDSkpKQwdOhStVsucOXMIDg5Gr9eTmJhIZmYmv/7669V+VCGEEH+ATBEK8Qds3LgROzu7FkstQN0uwYkTJ7Jx40YKCwvZtm0bjzzyCB9//DFarZbo6GieffZZhgwZgp2dnfq+0NBQkpKSWL58ORs2bCA/Px8fHx/69u172YrmQgghri8ygiXENbJlyxaio6P5+eefGTJkyLW+HSGEEBYkAUuIq6CiogJ7e3v169raWsaOHUtSUhI5OTlmx4QQQvz1yRShEFfBwoULqaioICIigqqqKuLi4ti7dy8vvfSShCtxzaxZs4bXXnuNnJwcevfuzdtvv82AAQOu9W0JcUOQESwhroLPPvuMN954g/T0dCorKwkJCWHu3LksWLDgWt+auElt2rSJ++67j3Xr1jFw4EBWrlzJV199xYkTJ9Q6ZEKIP04ClhBC3IQGDhxI//79Wb16NVC387Vdu3YsXLiQp59++hrfnRB/fdIqRwghbjLV1dUkJyebFbTVarWMGTOGxMTEa3hnQtw4JGAJIcRNJi8vj9raWnx9fc1e9/X1VavwCyH+HAlYQgghhBAWJgFLCCGukjVr1hAUFISdnR0DBw5k//791+Q+vLy8sLKyQq/Xm72u1+vx8/O7JvckxI1GApYQQlwFmzZt4vHHH+fZZ5/l4MGD9O7dm3HjxmEwGK76vdjY2BAeHs7OnTvV10wmEzt37iQiIuKq348QNyLZRSiEEFfB9bZrb9OmTcyaNYv169czYMAAVq5cyZdffsnx48ebrc0SQvzvpNCoEEJcYfW79hYvXqy+dq137U2fPp3c3FyWLVtGTk4Offr0YceOHRKuhLAQCVhCCHGFXW7X3vHjx6/RXcGCBQuk2K0QV4iswRJCCCGEsDAJWEIIcYXJrj0hbj4SsIQQ4gqTXXtC3HxkDZYQQlwFjz/+OLNmzaJfv37qrr2ysjJmz559rW9NCHEFSMASQoirQHbtCXFzkTpYQgghhBAWJmuwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsIkYAkhhBBCWJgELCGEEEIIC5OAJYQQQghhYRKwhBBCCCEsTAKWEEIIIYSFScASQgghhLAwCVhCCCGEEBYmAUsIIYQQwsL+P4vKyNHc7lxTAAAAAElFTkSuQmCC",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -344,7 +334,7 @@
     "    alpha=(0.1, 0.5),\n",
     "    beta=(1e-5, 1e-3),\n",
     "    methods=[\"hazard\", \"survival\"],\n",
-    "    age_max=200000,\n",
+    "    age_max=800000,\n",
     "    energy_max=20,\n",
     "    hazard_cls=bd.ELGompertzHazard,\n",
     ")"
@@ -352,14 +342,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
+   "id": "640d1bb2-a69f-43b3-895a-c4898b0ce0fb",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
    "id": "345da544-b55e-4747-af47-83678795a34a",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "ba38ba9e213a4a1292d53bf5ff083702",
+       "model_id": "b250e785721a4ae29a3285494ee53722",
        "version_major": 2,
        "version_minor": 0
       },
@@ -367,25 +365,25 @@
        "VBox(children=(Text(value='figure.png', description='Filename:'), Button(description='Save File', style=Button…"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "bb149c3df1344e7598e921bb737a8a5a",
+       "model_id": "a6d1f21302664601bcfd8db3ab56fb5c",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -409,14 +407,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 23,
    "id": "aa8772da-cede-4eff-870b-d2435c902662",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "6bb30290f1374e1da53b266d158cf480",
+       "model_id": "bae01f43d25743a0ae50c68129e707d5",
        "version_major": 2,
        "version_minor": 0
       },
@@ -424,25 +422,25 @@
        "VBox(children=(Text(value='figure.png', description='Filename:'), Button(description='Save File', style=Button…"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 23,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "210c1b3bc02c45ada6ff0fe5e173a685",
+       "model_id": "eecb006a1dde42d3a227ebf87f26fb90",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
diff --git a/smoke-tests/circle_ppo.py b/smoke-tests/circle_ppo.py
index 6c61b982..ca6a5317 100644
--- a/smoke-tests/circle_ppo.py
+++ b/smoke-tests/circle_ppo.py
@@ -46,12 +46,13 @@ def visualize(
     n_steps: int,
     videopath: Path | None,
     headless: bool,
+    figsize: tuple[float, float],
 ) -> None:
     keys = jax.random.split(key, n_steps + 1)
     state, ts = env.reset(keys[0])
     obs = ts.obs
     backend = "headless" if headless else "pyglet"
-    visualizer = env.visualizer(state, figsize=(640.0, 640.0), backend=backend)
+    visualizer = env.visualizer(state, figsize=figsize, backend=backend)
     if videopath is not None:
         visualizer = SaveVideoWrapper(visualizer, videopath, fps=60)
 
@@ -174,6 +175,7 @@ def run_training(
     n_total_steps: int,
     action_reward_coef: float,
     entropy_weight: float,
+    figsize: tuple[float, float],
     reset_interval: int | None = None,
     debug_vis: bool = False,
 ) -> tuple[NormalPPONet, jax.Array]:
@@ -196,7 +198,7 @@ def run_training(
     rewards = jnp.zeros(N_MAX_AGENTS)
     keys = jax.random.split(key, n_loop)
     if debug_vis:
-        visualizer = env.visualizer(env_state, figsize=(640.0, 640.0))
+        visualizer = env.visualizer(env_state, figsize=figsize)
     else:
         visualizer = None
     for i, key in enumerate(keys):
@@ -254,6 +256,8 @@ def train(
     env_override: str = "",
     reset_interval: Optional[int] = None,
     savelog_path: Optional[Path] = None,
+    xlim: Optional[float] = None,
+    ylim: Optional[float] = None,
     debug_vis: bool = False,
 ) -> None:
     # Load config
@@ -264,6 +268,8 @@ def train(
     cfconfig.n_initial_agents = n_agents
     cfconfig.n_max_agents = N_MAX_AGENTS
     env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
+    xsize = cfconfig.xlim[1] * 2 if xlim is None else xlim
+    ysize = cfconfig.ylim[1] * 2 if ylim is None else ylim
     network, rewards = run_training(
         key=jax.random.PRNGKey(seed),
         n_agents=n_agents,
@@ -277,6 +283,7 @@ def train(
         n_total_steps=n_total_steps,
         action_reward_coef=action_reward_coef,
         entropy_weight=entropy_weight,
+        figsize=(xsize, ysize),
         reset_interval=reset_interval,
         debug_vis=debug_vis,
     )
@@ -293,6 +300,8 @@ def vis(
     cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
     seed: int = 1,
     videopath: Optional[Path] = None,
+    xlim: Optional[float] = None,
+    ylim: Optional[float] = None,
     env_override: str = "",
     headless: bool = False,
 ) -> None:
@@ -315,7 +324,17 @@ def vis(
         jax.random.split(net_key, N_MAX_AGENTS),
     )
     pponet = eqx.tree_deserialise_leaves(modelpath, pponet)
-    visualize(eval_key, env, pponet, n_total_steps, videopath, headless)
+    xsize = cfconfig.xlim[1] * 2 if xlim is None else xlim
+    ysize = cfconfig.ylim[1] * 2 if ylim is None else ylim
+    visualize(
+        key=eval_key,
+        env=env,
+        network=pponet,
+        n_steps=n_total_steps,
+        videopath=videopath,
+        headless=headless,
+        figsize=(xsize, ysize),
+    )
 
 
 if __name__ == "__main__":

From aa27af63fac0822f0d92ecb33bcab8e898509bf1 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 26 Jan 2024 17:00:06 +0900
Subject: [PATCH 223/337] Square f80

---
 config/env/20240126-square-f80.toml | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 config/env/20240126-square-f80.toml

diff --git a/config/env/20240126-square-f80.toml b/config/env/20240126-square-f80.toml
new file mode 100644
index 00000000..f5f22e7e
--- /dev/null
+++ b/config/env/20240126-square-f80.toml
@@ -0,0 +1,29 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 50
+food_num_fn = ["logistic", 20, 0.01, 50]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From b1b92c48011e283257e14bcf025b77f813673e27 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 29 Jan 2024 17:50:56 +0900
Subject: [PATCH 224/337] mild2

---
 config/bd/20240129-mild2.toml | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 config/bd/20240129-mild2.toml

diff --git a/config/bd/20240129-mild2.toml b/config/bd/20240129-mild2.toml
new file mode 100644
index 00000000..ae3d0af2
--- /dev/null
+++ b/config/bd/20240129-mild2.toml
@@ -0,0 +1,14 @@
+birth_fn = "emevo.birth_and_death.EnergyLogisticBirth"
+hazard_fn = "emevo.birth_and_death.ELGompertzHazard"
+
+[hazard_params]
+alpha = 0.1
+alpha_age = 1e-6
+beta = 1e-5
+scale = 0.01
+e0 = 0.0
+
+[birth_params]
+alpha = 0.01
+scale = 2e-4
+e0 = 10.0
\ No newline at end of file

From 2362b39d0aa712ea44eedeac40df2f6683801b83 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 29 Jan 2024 17:52:52 +0900
Subject: [PATCH 225/337] Seasons f80

---
 config/env/20240129-seasons-f80.toml | 40 ++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 config/env/20240129-seasons-f80.toml

diff --git a/config/env/20240129-seasons-f80.toml b/config/env/20240129-seasons-f80.toml
new file mode 100644
index 00000000..d6d7857e
--- /dev/null
+++ b/config/env/20240129-seasons-f80.toml
@@ -0,0 +1,40 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["switching",
+       1000,
+       ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+   ],
+]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From b3fd805383af4401dbc1d64142a1327fb42e59b9 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Tue, 30 Jan 2024 00:06:54 +0900
Subject: [PATCH 226/337] Fix seasons-f80

---
 config/env/20240129-seasons-f80.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config/env/20240129-seasons-f80.toml b/config/env/20240129-seasons-f80.toml
index d6d7857e..fb1d46fc 100644
--- a/config/env/20240129-seasons-f80.toml
+++ b/config/env/20240129-seasons-f80.toml
@@ -11,9 +11,9 @@ food_loc_fn = [
        ["gaussian", [360.0, 270.0], [48.0, 36.0]],
        ["gaussian", [240.0, 270.0], [48.0, 36.0]],
        ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 270.0], [48.0, 36.0]],
    ],
 ]
-food_loc_fn = "gaussian"
 agent_loc_fn = "uniform"
 xlim = [0.0, 480.0]
 ylim = [0.0, 360.0]

From 77b1d6463cc4068e0b6d0ee73ba993e80d4c2e97 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 30 Jan 2024 17:50:43 +0900
Subject: [PATCH 227/337] More plotting functions

---
 notebooks/bd_rate.ipynb            | 60 ++++++++------------
 src/emevo/analysis/log_plotting.py | 88 +++++++++++++++++++++---------
 2 files changed, 83 insertions(+), 65 deletions(-)

diff --git a/notebooks/bd_rate.ipynb b/notebooks/bd_rate.ipynb
index 4ebb4fac..313cf6b6 100644
--- a/notebooks/bd_rate.ipynb
+++ b/notebooks/bd_rate.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 1,
    "id": "0dadbf8d-d3eb-42b8-a9c1-265e61f6edd8",
    "metadata": {},
    "outputs": [],
@@ -32,7 +32,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 2,
    "id": "c4b6ebde-ea34-4a3e-92b3-964ac39c8452",
    "metadata": {},
    "outputs": [],
@@ -66,7 +66,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 3,
    "id": "8d94990f-99ac-4dc0-a5c9-1b19806b8885",
    "metadata": {},
    "outputs": [],
@@ -94,7 +94,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 4,
    "id": "8c0388cd-0f78-4094-8129-a448bd2446e0",
    "metadata": {},
    "outputs": [],
@@ -155,7 +155,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 5,
    "id": "f6e5195d-4ce1-4b04-a74b-a7abe805810b",
    "metadata": {},
    "outputs": [],
@@ -229,7 +229,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 6,
    "id": "b6836a43-b466-4d86-9094-21a3560624cd",
    "metadata": {},
    "outputs": [],
@@ -281,14 +281,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 7,
    "id": "caf049a1-8651-46bf-82e8-84c249545b13",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "e46c965f352b455f937f67e3bc154557",
+       "model_id": "8170587f17754abc98b01ddb4dcfe4d5",
        "version_major": 2,
        "version_minor": 0
       },
@@ -296,14 +296,14 @@
        "VBox(children=(Text(value='figure.png', description='Filename:'), Button(description='Save File', style=Button…"
       ]
      },
-     "execution_count": 20,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "d657b9b7d02b4e7596b6360d5914eb35",
+       "model_id": "dbdaba9d8e514257b2452a7b675bfdae",
        "version_major": 2,
        "version_minor": 0
       },
@@ -342,22 +342,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "640d1bb2-a69f-43b3-895a-c4898b0ce0fb",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "id": "345da544-b55e-4747-af47-83678795a34a",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "b250e785721a4ae29a3285494ee53722",
+       "model_id": "cc15722aa33c4626b1d2454828487ea0",
        "version_major": 2,
        "version_minor": 0
       },
@@ -365,14 +357,14 @@
        "VBox(children=(Text(value='figure.png', description='Filename:'), Button(description='Save File', style=Button…"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "a6d1f21302664601bcfd8db3ab56fb5c",
+       "model_id": "0f811687744342498bf7c9cc17d93956",
        "version_major": 2,
        "version_minor": 0
       },
@@ -407,14 +399,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 9,
    "id": "aa8772da-cede-4eff-870b-d2435c902662",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "bae01f43d25743a0ae50c68129e707d5",
+       "model_id": "3d804640596341dabed17ae972e4986a",
        "version_major": 2,
        "version_minor": 0
       },
@@ -422,25 +414,25 @@
        "VBox(children=(Text(value='figure.png', description='Filename:'), Button(description='Save File', style=Button…"
       ]
      },
-     "execution_count": 23,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "eecb006a1dde42d3a227ebf87f26fb90",
+       "model_id": "118f5f2457d548b1ac51be6334d2bb9f",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAASwCAYAAAAnoTQJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVxU1fsH8M+wDcMyIIgsLoAb7rsiblguaGbqr7TUSsx9KZfKskxxL8tyKb9qi2hpmqW2uIW4pIa4gjsiYqgoroiobDPP7w/i5sg24LD6eb9evGrOPffc58xwx4dzzz1XJSICIiIiIjIZs5IOgIiIiKi8YYJFREREZGJMsIiIiIhMjAkWERERkYkxwSIiIiIyMSZYRERERCbGBIuIiIjIxJhgEREREZkYEywiIiIiE2OCRURERGRiTLCIiIiITIwJFhEREZGJMcEiIiIiMjEmWEREREQmxgSLiIiIyMSYYBERERGZGBMsIiIiIhNjgkVERERkYkywiIiIiEyMCRYRERGRiTHBIiIiIjIxJlhEREREJsYEi4iIiMjEmGARERERmRgTLCIiIiITY4JFREREZGJMsIiIiIhMjAkWERERkYkxwSIiIiIyMSZYRERERCbGBIuIiIjIxJhgEREREZkYEywiIiIiE2OCRURERGRiTLCIiIiITIwJFhEREZGJMcEiIiIiMjEmWEREREQmxgSLiIiIyMSYYBERERGZGBMsIiIiIhNjgmViFy9ehEqlQkREhNH7BAcHw9HRschiIipNOnbsiPHjx5d0GERERYoJ1lNm+fLl6NixI7RaLVQqFRITE43a76uvvoKXlxesra3h6+uLgwcPGmxPSUnBmDFj4OzsDDs7O7z44otISEh44nhFBFOnToW7uzs0Gg06d+6M6OhogzqzZ89GmzZtYGNjw0T1KVGUf5TcunUL3bp1g4eHB9RqNapWrYqxY8ciKSkpz/2M/T0MDg5Go0aNYG1tjUqVKmHMmDFPHLMx559Kpcr2s3bt2ic+NhHljAnWU+bBgwfo1q0bPvjgA6P3WbduHSZOnIhp06bh6NGjaNy4MQICAnD9+nWlzoQJE/D7779j/fr12LNnD+Lj4/F///d/TxzvvHnzsGjRIixduhTh4eGwtbVFQEAAUlJSlDppaWno27cvRo0a9cTHIzIzM0OvXr3w22+/4dy5cwgODsaOHTswcuTIPPcz5vfw888/x4cffoj3338fp06dwo4dOxAQEPDEMRt7/q1YsQJXr15Vfnr37v3ExyaiXAgVyNatW6Vt27bi4OAgTk5O0qNHDzl//ryyPTY2VgDIsWPHRERk165dAkD++OMPadiwoajVavH19ZUTJ04o+6xYsUIcHBxk27ZtUqdOHbG1tZWAgACJj49X6hw8eFA6d+4szs7OotVqpUOHDnLkyJFC9yMrrjt37uRbt1WrVjJmzBjltU6nEw8PD5k7d66IiCQmJoqlpaWsX79eqXPmzBkBIGFhYUrZiRMnpFu3bmJrayuVKlWSV199VW7cuJHrcfV6vbi5ucmnn36qlCUmJoparZYff/wxW/2s95FKN39/fxkzZoyMGTNGtFqtODs7y5QpU0Sv1yt1UlJS5O233xYPDw+xsbGRVq1aya5du0Tkv9/dR3+mTZsmIiKrVq2S5s2bi52dnbi6ukr//v0lISHhiWNeuHChVKlSxai6uf0e3r59WzQajezYsSPP/ffu3Svt2rUTa2trqVKlirz55puSnJyca31jzz8AsnHjRqP6QERPjiNYBXT//n1MnDgRhw8fRmhoKMzMzNCnTx/o9fo893v33Xcxf/58HDp0CC4uLujZsyfS09OV7Q8ePMBnn32G77//Hn/99Rfi4uLwzjvvKNvv3buHQYMGYd++fThw4ABq1aqF5557Dvfu3VPqBAYGomPHjibtb1paGo4cOYLOnTsrZWZmZujcuTPCwsIAAEeOHEF6erpBnTp16qBatWpKncTERDz77LNo2rQpDh8+jG3btiEhIQH9+vXL9dixsbG4du2aQbsODg7w9fVV2qWyaeXKlbCwsMDBgwexcOFCfP755/jmm2+U7WPHjkVYWBjWrl2L48ePo2/fvujWrRuio6PRpk0bLFiwAFqtVhmJyTpX0tPTMXPmTERGRmLTpk24ePEiAgMDDY7t5eWFoKAgo2ONj4/Hhg0b4O/v/0R9DgkJgV6vx5UrV1C3bl1UqVIF/fr1w6VLl5Q6MTEx6NatG1588UUcP34c69atw759+zB27Nhc2zXm/MsyZswYVKxYEa1atcJ3330HEXmiPhFRHko6wyvrbty4IQCUEancRrDWrl2r7HPr1i3RaDSybt06Ecn8ixeAwUjYV199Ja6urrkeV6fTib29vfz+++9K2fvvvy+vvfaaUXEbO4J15coVASB///23Qfm7774rrVq1EhGR1atXi5WVVbZ9W7ZsKZMmTRIRkZkzZ0rXrl0Ntl+6dEkASFRUVI7H3r9/vwAwGMkTEenbt6/069cvW32OYJUN/v7+UrduXYMRq/fee0/q1q0rIiL//POPmJuby5UrVwz269Spk0yePFlEjP+sDx06JADk3r17Stmzzz4rixcvznffV155RTQajQCQnj17ysOHD43pXq6xzZ07VywtLcXHx0e2bdsmYWFh0qlTJ/Hx8ZHU1FQRERkyZIgMHz7cYL+9e/eKmZlZrsc35vwTEZkxY4bs27dPjh49Kh9//LGo1WpZuHChUX0iooKzKKnErqyKjo7G1KlTER4ejps3byojV3FxcWjQoEGu+/n5+Sn/7+TkBB8fH5w5c0Yps7GxQY0aNZTX7u7uBnOcEhISMGXKFOzevRvXr1+HTqfDgwcPEBcXp9SZO3euSfpYFCIjI7Fr1y7Y2dll2xYTE4NDhw5hxIgRStnWrVthbm5enCFSMWrdujVUKpXy2s/PD/Pnz4dOp8OJEyeg0+lQu3Ztg31SU1Ph7OycZ7tHjhxBUFAQIiMjcefOHYPzs169egCA0NBQo2L84osvMG3aNJw7dw6TJ0/GxIkTsWTJkoJ004Ber0d6ejoWLVqErl27AgB+/PFHuLm5YdeuXQgICEBkZCSOHz+O1atXK/uJCPR6PWJjY7Fx40bMmTNH2Xb69Gmjj//RRx8p/9+0aVPcv38fn376Kd56661C94mIcscEq4B69uwJT09PfP311/Dw8IBer0eDBg2Qlpb2RO1aWloavFapVAbD94MGDcKtW7ewcOFCeHp6Qq1Ww8/P74mPm5+KFSvC3Nw82x1JCQkJcHNzAwC4ubkhLS0NiYmJBndPPVonOTkZPXv2xCeffJLtGO7u7tDr9fD19VXKKleujKtXryrtuLu7G7TbpEkTU3WRSpnk5GSYm5vjyJEj2ZLsnBL0LPfv30dAQAACAgKwevVquLi4IC4uDgEBAYU6T9zc3ODm5oY6derAyckJ7du3x0cffWTwu1gQWftlJXoA4OLigooVKyp/KCUnJ2PEiBE5Jj3VqlXDyJEjDS6re3h4GHX+5cTX1xczZ85Eamoq1Gp1ofpERLljglUAt27dQlRUFL7++mu0b98eALBv3z6j9j1w4ACqVasGALhz5w7OnTuHunXrGn3s/fv3Y8mSJXjuuecAAJcuXcLNmzcL2IOCs7KyQvPmzREaGqrccaTX6xEaGqrMC2nevDksLS0RGhqKF198EQAQFRWFuLg4ZeSuWbNm+OWXX+Dl5QULi5x/7ezt7Q1ee3t7w83NDaGhoUpClZSUhPDwcN4xWMaFh4cbvM6aV2hubo6mTZtCp9Ph+vXrynn2OCsrK+h0OoOys2fP4tatW/j4449RtWpVAMDhw4dNEm/WSFhqamqh22jbti2AzHOjSpUqAIDbt2/j5s2b8PT0BJB5npw+fRo1a9bMsQ0nJyc4OTkZlBlz/uUkIiICFSpUYHJFVFRK+hplWaLT6cTZ2VleffVViY6OltDQUGnZsqXB3Tm5zcGqX7++7NixQ06cOCEvvPCCVKtWTZl3kdOcjY0bN8qjH0/Tpk2lS5cucvr0aTlw4IC0b99eNBqNfPHFF0odY+ZgXb16VY4dOyZff/21AJC//vpLjh07Jrdu3VLqPD5HZe3ataJWqyU4OFhOnz4tw4cPF0dHR7l27ZpSZ+TIkVKtWjXZuXOnHD58WPz8/MTPz0/ZfuXKFXFxcZGXXnpJDh48KOfPn5dt27ZJYGCgZGRk5Brvxx9/LI6OjvLrr7/K8ePHpVevXuLt7W0wH+Wff/6RY8eOyfTp08XOzk6OHTsmx44dM5h3Q6WHv7+/2NnZyYQJE+Ts2bOyZs0asbW1laVLlyp1Bg4cKF5eXvLLL7/IhQsXJDw8XObMmSN//PGHiPw3P2/Hjh1y48YNuX//vly/fl2srKzk3XfflZiYGPn111+ldu3aBuejSP5zsDZv3izfffednDhxQmJjY+WPP/6QunXrStu2bZU64eHh4uPjI5cvX1bKjPk97NWrl9SvX1/2798vJ06ckOeff17q1asnaWlpIiISGRkpGo1GxowZI8eOHZNz587Jpk2bDO7izUl+599vv/0mX3/9tZw4cUKio6NlyZIlYmNjI1OnTs3n0yKiwmKCVUAhISFSt25dUavV0qhRI9m9e7dRCdbvv/8u9evXFysrK2nVqpVERkYqbRqTYB09elRatGgh1tbWUqtWLVm/fr14enoaJFiDBg0Sf3//POOfNm1atlvcAciKFSuUOp6enspt71kWL14s1apVU+I/cOCAwfaHDx/K6NGjpUKFCmJjYyN9+vSRq1evGtQ5d+6c9OnTRxwdHUWj0UidOnVk/PjxBpOdH6fX6+Wjjz4SV1dXUavV0qlTp2yT4gcNGpRjn7Ju66fSxd/fX0aPHi0jR44UrVYrFSpUkA8++MDg9yAtLU2mTp0qXl5eYmlpKe7u7tKnTx85fvy4UmfkyJHi7OxssEzDmjVrxMvLS9Rqtfj5+clvv/2WLcHK6ff7UTt37hQ/Pz9xcHBQzrf33nvP4IaQrPM6NjZWKTPm9/Du3bvyxhtviKOjozg5OUmfPn0kLi7O4PgHDx6ULl26iJ2dndja2kqjRo1k9uzZeb6n+Z1/W7dulSZNmihtNm7cWJYuXSo6nS7Pdomo8FQivE+3KO3evRvPPPMM7ty5w1XGiYiInhJcB4uIiIjIxJhgEREREZkYLxESERERmRhHsIiIiIhMjAkWERWrjh07Yvz48XnW8fLywoIFC4qs/ZISGBiorCdHROUbE6xSJDg4mHcaEgE4dOgQhg8fnmed3bt3Q6VSITExsXiCKqVu3bqFbt26wcPDA2q1GlWrVsXYsWORlJSU536zZ89GmzZtYGNjk+f3TnBwMBo1agRra2tUqlQJY8aMeeKYU1JSMGbMGDg7O8POzg4vvvhitqdFqFSqbD9r16594mMTFRcmWE+B5cuXo2PHjtBqtQX6B+mrr76Cl5cXrK2t4evri4MHDxpsN+ZLsjBEBFOnToW7uzs0Gg06d+6M6OhogzrG/uNAZZOLiwtsbGxy3Z6enl6M0ZRuZmZm6NWrF3777TecO3cOwcHB2LFjB0aOHJnnfmlpaejbt2+eT0X4/PPP8eGHH+L999/HqVOnsGPHDgQEBDxxzBMmTMDvv/+O9evXY8+ePYiPj8f//d//Zau3YsUKXL16Vfnh6B+VJUywngIPHjxAt27d8MEHHxi9z7p16zBx4kRMmzYNR48eRePGjREQEGDwAGpjvyQLat68eVi0aBGWLl2K8PBw2NraIiAgACkpKUodY/5xoNIrIyMDY8eOhYODAypWrIiPPvrI4Nmbj18iVKlU+N///ocXXngBtra2GDZsGJ555hkAQIUKFaBSqRAYGKjU1+v1mDRpEpycnODm5oagoCCj4hIRBAUFoVq1alCr1fDw8DB4LmBqairee+89VK1aFWq1GjVr1sS3334LANDpdBgyZAi8vb2h0Wjg4+ODhQsX5nk8vV6PuXPnKvs0btwYP//8s1GxZqlQoQJGjRqFFi1awNPTE506dcLo0aOxd+/ePPebPn06JkyYgIYNG+a4/c6dO5gyZQpWrVqFAQMGoEaNGmjUqBFeeOEFg3r79u1D+/btodFoULVqVbz11lu4f/9+rse9e/cuvv32W3z++ed49tln0bx5c6xYsQJ///03Dhw4YFDX0dFReSakm5sbrK2tjXxXiEqBElzktExav369NGjQQKytrcXJyUk6deokycnJyvZvv/1W6tWrJ1ZWVuLm5mbwiIv58+dLgwYNxMbGRqpUqSKjRo0yeIxGTiu6b9q0SZo2bSpqtVq8vb0lKChI0tPTCxV71urTj65InZtWrVoZxK7T6cTDw0Pmzp0rIiKJiYliaWkp69evV+qcOXNGAEhYWJhSduLECenWrZvY2tpKpUqV5NVXX5UbN27kely9Xi9ubm7y6aefKmWJiYmiVqvlxx9/zFY/p/eMSresR+WMGzdOzp49Kz/88IPY2NjI8uXLlTqPP6UAgFSqVEm+++47iYmJkYsXL8ovv/wiACQqKkquXr0qiYmJSvtarVaCgoLk3LlzsnLlSlGpVPLnn3/mG9v69etFq9XKli1b5J9//pHw8HCDuPr16ydVq1aVDRs2SExMjOzYsUPWrl0rIv+tPn/o0CG5cOGC0q9169Yp+w8aNEh69eqlvJ41a5bUqVNHtm3bJjExMbJixQpRq9Wye/dug/cir5XnH3flyhXx9/eXgQMHGlU/t3No3bp1olarZeXKlVKnTh2pXLmy9O3b12Dl+fPnz4utra188cUXcu7cOdm/f780bdpUAgMDcz1eaGhojt9D1apVk88//1x5DUA8PDzE2dlZWrZsKd9++22eT30gKm2YYBVAfHy8WFhYyOeffy6xsbFy/Phx+eqrr5QkacmSJWJtbS0LFiyQqKgoOXjwoME/El988YXs3LlTYmNjJTQ0VHx8fGTUqFHK9se/6P766y/RarUSHBwsMTEx8ueff4qXl5cEBQUpdYx5PE4WYxOs1NRUMTc3Vx7/k+X111+XF154QUSM+5K8c+eOuLi4yOTJk+XMmTNy9OhR6dKlizzzzDO5HjsmJibbo01ERDp06CBvvfVWtvpMsMoef39/qVu3rsE/lu+9957UrVtXeZ1TgjV+/HiDdnL7ffb395d27doZlLVs2VLee++9fGObP3++1K5dW3k24KOioqIEgISEhOTbTpYxY8bIiy++qLx+NMFKSUkRGxsb+fvvvw32GTJkiPTv3195nd+zE7O88sorotFoBID07NnT4HmdecntHJo7d65YWlqKj4+PbNu2TcLCwqRTp07i4+OjPEd1yJAhMnz4cIP99u7dK2ZmZrkef/Xq1WJlZZWtvGXLljJp0iTl9YwZM2Tfvn1y9OhR+fjjj0WtVsvChQuN6hNRaWBRIsNmZdTVq1eRkZGB//u//4OnpycAGAyvz5o1C2+//TbGjRunlLVs2VL5/0fvbPLy8sKsWbMwcuRILFmyJMfjTZ8+He+//z4GDRoEAKhevTpmzpyJSZMmYdq0aQAAd3d36PV6k/URAG7evAmdTgdXV1eDcldXV5w9exYAcO3aNVhZWWWb/+Tq6opr164BAL788ks0bdoUc+bMUbZ/9913qFq1Ks6dO4fatWtnO3bWvjkdO2sblX2tW7eGSqVSXvv5+WH+/PnQ6XQwNzfPcZ8WLVoY3X6jRo0MXru7uxtc3s5N3759sWDBAlSvXh3dunXDc889h549e8LCwgIREREwNzeHv79/rvt/9dVX+O677xAXF4eHDx8iLS0NTZo0ybHu+fPn8eDBA3Tp0sWgPC0tDU2bNlVeh4aG5hs3AHzxxReYNm0azp07h8mTJ2PixIm5frcYQ6/XIz09HYsWLULXrl0BAD/++CPc3Nywa9cuBAQEIDIyEsePH8fq1auV/UQEer0esbGx2Lhxo8H5f/r0aaOP/9FHHyn/37RpU9y/fx+ffvqpwSVbotKMCVYBNG7cGJ06dULDhg0REBCArl274qWXXkKFChVw/fp1xMfHo1OnTrnuv2PHDsydOxdnz55FUlISMjIykJKSggcPHuQ4oTcyMhL79+/H7NmzlTKdTmewz9y5c4ukr6YQGRmJXbt2wc7OLtu2mJgYHDp0CCNGjFDKtm7dmus/rkS2trZG17W0tDR4rVKpjPpDpGrVqoiKisKOHTsQEhKC0aNH49NPP8WePXug0Wjy3Hft2rV45513MH/+fPj5+cHe3h6ffvopwsPDc6yfnJwMANi8eTMqV65ssE2tVucb6+Oy5inVqVMHTk5OaN++PT766CO4u7sXuC0Ayn716tVTylxcXFCxYkXExcUpfRgxYkSOSU+1atUwcuRI9OvXTynz8PCAm5sb0tLSkJiYaPAHWkJCAtzc3HKNx9fXFzNnzkRqamqh3h+i4sYEqwDMzc0REhKCv//+G3/++ScWL16MDz/8EOHh4ahYsWKe+168eBHPP/88Ro0ahdmzZ8PJyQn79u3DkCFDkJaWlmOClZycjOnTp+c4cbwoJ3tWrFgR5ubm2e4IfPQL0JgvyeTkZPTs2ROffPJJtmNkjbz5+voqZZUrV8bVq1eVdh79hyEhISHXkQAqex5POg4cOIBatWoVKMG2srICkPlHhylpNBr07NkTPXv2xJgxY1CnTh2cOHECDRs2hF6vx549e9C5c+ds++3fvx9t2rTB6NGjlbKYmJhcj1OvXj2o1WrExcXlOSpWGFnJZGpqaqHbaNu2LQAgKioKVapUAQDcvn0bN2/eVEbwmzVrhtOnT6NmzZo5tuHk5AQnJyeDsubNm8PS0hKhoaF48cUXlWPExcXBz88v13giIiJQoUIFJldUZjDBKiCVSoW2bduibdu2mDp1Kjw9PbFx40ZMnDgRXl5eCA0NVe5uetSRI0eg1+sxf/58mJll3rz5008/5XmsZs2aISoqKtcvr6JiZWWF5s2bIzQ0VLktWq/XIzQ0FGPHjgVg3Jdks2bN8Msvv8DLywsWFjn/qtnb2xu89vb2hpubG0JDQ5WEKikpCeHh4bxjsByJi4vDxIkTMWLECBw9ehSLFy/G/PnzC9SGp6cnVCoV/vjjDzz33HPQaDQ5jpYWRHBwMHQ6HXx9fWFjY4MffvgBGo0Gnp6ecHZ2xqBBg/DGG29g0aJFaNy4Mf755x9cv34d/fr1Q61atbBq1Sps374d3t7e+P7773Ho0CF4e3vneCx7e3u88847mDBhAvR6Pdq1a4e7d+9i//790Gq1ytSATp06oU+fPsq597gtW7YgISEBLVu2hJ2dHU6dOoV3330Xbdu2hZeXFwDg4MGDeP311xEaGqqMlsXFxeH27duIi4uDTqdDREQEAKBmzZqws7ND7dq10atXL4wbNw7Lly+HVqvF5MmTUadOHeU77r333kPr1q0xduxYDB06FLa2tjh9+jRCQkLw5Zdf5hivg4MDhgwZgokTJ8LJyQlarRZvvvkm/Pz80Lp1awDA77//joSEBLRu3RrW1tYICQnBnDlz8M477xTqcyUqESU9CawsOXDggMyePVsOHTok//zzj/z0009iZWUlW7ZsERGR4OBgsba2loULF8q5c+fkyJEjsmjRIhERiYiIEACyYMECiYmJkVWrVknlypUNJuk+Ptl027ZtYmFhIUFBQXLy5Ek5ffq0/Pjjj/Lhhx8qdd5//3157bXX8oz76tWrcuzYMfn6668FgPz1119y7NgxuXXrllLn8Ym0a9euFbVaLcHBwXL69GkZPny4ODo6yrVr15Q6I0eOlGrVqsnOnTvl8OHD4ufnJ35+fsr2K1euiIuLi7z00kty8OBBOX/+vGzbtk0CAwMlIyMj13g//vhjcXR0lF9//VWOHz8uvXr1Em9vb4NJs//8848cO3ZMpk+fLnZ2dnLs2DE5duyYwV2ZVDr5+/vL6NGjZeTIkaLVaqVChQrywQcfGEx6z2mS++M3XYhkToR2c3MTlUolgwYNUtofN26cQb1evXop2/OyceNG8fX1Fa1WK7a2ttK6dWvZsWOHsv3hw4cyYcIEcXd3FysrK6lZs6Z89913IpI5aT0wMFAcHBzE0dFRRo0aJe+//740btxY2f/xuwj1er0sWLBAfHx8xNLSUlxcXCQgIED27Nlj8F7kdRfhzp07xc/PTxwcHMTa2lpq1aol7733nsHk/6wbAmJjYw1iAZDtZ9euXUqdu3fvyhtvvCGOjo7i5OQkffr0MbiLUETk4MGD0qVLF7GzsxNbW1tp1KiRzJ49O8/3+eHDhzJ69GipUKGC2NjYSJ8+feTq1avK9q1bt0qTJk2UNhs3bixLly4VnU6XZ7tEpQkTrAI4ffq0BAQEiIuLi6jVaqldu3a2u3uWLl2qfFm6u7vLm2++qWz7/PPPxd3dXTQajQQEBMiqVavyTLBEMpOsNm3aiEajEa1WK61atTK4bdyYuwinTZuW4xfpihUrlDo5fYkvXrxYqlWrJlZWVtKqVSs5cOCAwfb8viRFRM6dOyd9+vQRR0dH0Wg0UqdOHRk/fnyet1vr9Xr56KOPxNXVVdRqtXTq1EmioqIM6hjzjwMREVFJUYk8srofERERET0xruRORE+N1atXw87OLsef+vXrl3R4RFSOcASLiJ4a9+7dy/V5mZaWlsrdcURET4oJFhEREZGJ8RIhERERkYkxwSKiYtWxY0eDx0blxMvLCwsWLCiy9p9EcHBwtkdE5ScwMFBZU46Ing5MsIpAXFwcevToARsbG1SqVAnvvvsuMjIyCtTG7t27oVKpsv3k9zy+48ePo3379rC2tkbVqlUxb968bHXWr1+POnXqwNraGg0bNsSWLVsKFFthfPXVV/Dy8oK1tTV8fX1x8OBBg+0pKSkYM2YMnJ2dYWdnhxdffDHXuTJU/h06dAjDhw/Ps07WOZKYmFg8QZURb731Fpo3bw61Wm300w+MOf9M8b2Wk9u3b2PgwIHQarVwdHTEkCFDlMcIZcUWGBiIhg0bwsLCgokqlRlMsExMp9OhR48eSEtLw99//42VK1ciODgYU6dOLVR7UVFRuHr1qvJTqVKlXOsmJSWha9eu8PT0xJEjR/Dpp58iKCgIy5cvV+r8/fff6N+/P4YMGYJjx46hd+/e6N27N06ePFmo+IDMv+g7duyY6/Z169Zh4sSJmDZtGo4ePYrGjRsjICDA4OG7EyZMwO+//47169djz549iI+Pz/ERQfR0cHFxyfHxUVnS09OLMZqy54033sDLL79sdP38zj9Tf689auDAgTh16hRCQkLwxx9/4K+//jJIrnU6HTQaDd56660cH1FEVGqV5CJcZZFOp5M5c+aIl5eXWFtbS6NGjWT9+vXK9i1btoiZmZnBiuf/+9//RKvVSmpqqtHHyVp5+dHVmPOzZMkSqVChgsFx3nvvPfHx8VFe9+vXT3r06GGwn6+vr4wYMUJ5nZKSIm+//bZ4eHiIjY2NtGrVKs8FPFesWJHnYqetWrWSMWPGKK91Op14eHjI3LlzRUQkMTFRLC0tDd7HM2fOCAAJCwvLt99Utvj7+8uYMWNkzJgxotVqxdnZWaZMmZLvSu5LliyRnj17io2NTY4LzT66kvubb74p7777rlSoUEFcXV3zXAn9cfPnz5cGDRqIjY2NVKlSRUaNGmXwhIDHFwSeNm2astJ4lSpVRKPRSN++fSUxMVGpk7WC+6effipubm7i5OQko0ePlrS0NKXOqlWrpHnz5mJnZyeurq7Sv39/SUhIMP6NfUxWXPkx5vwz9ntt06ZN0rRpU1Gr1eLt7S1BQUGSnp6e67FPnz4tAOTQoUNK2datW0WlUsmVK1ey1X98JXyi0owjWAU0d+5crFq1CkuXLsWpU6cwYcIEvPrqq9izZw8AICwsDA0bNoSrq6uyT0BAAJKSknDq1CkAmQ9+VqlU2L17d77Ha9KkCdzd3dGlSxfs378/z7phYWHo0KGD8hDcrGNHRUXhzp07Sp3H/woMCAhAWFiY8nrs2LEICwvD2rVrcfz4cfTt2xfdunVDdHR0vvE+Li0tDUeOHDE4ppmZGTp37qwc88iRI0hPTzeoU6dOHVSrVs0gLio/Vq5cCQsLCxw8eBALFy7E559/jm+++SbPfYKCgtCnTx+cOHEC06dPxy+//ALgv1HehQsXGrRva2uL8PBwzJs3DzNmzEBISIhRsZmZmWHRokU4deoUVq5ciZ07d2LSpEl57nP+/Hn89NNP+P3337Ft2zYcO3bM4KHPALBr1y7ExMRg165dyghQcHCwsj09PR0zZ85EZGQkNm3ahIsXLyIwMNCgDS8vLwQFBRnVD2MZc/4Z8722d+9evP766xg3bhxOnz6NZcuWITg4GLNnz8712GFhYXB0dESLFi2Uss6dO8PMzCzbA8GJyho+7LkAUlNTMWfOHOzYsUN5oHH16tWxb98+LFu2DP7+/rh27ZrBlxAA5XXW/ClLS0v4+PjkeQnE3d0dS5cuRYsWLZCamopvvvkGHTt2RHh4OJo1a5bjPteuXcv2YNlHj12hQoVc48uKLS4uDitWrEBcXBw8PDwAAO+88w62bduGFStWYM6cOUa9V1lu3rwJnU6X4zHPnj2rxGZlZZVt4vCjcVH5UrVqVXzxxRdQqVTw8fHBiRMn8MUXX2DYsGG57jNgwAAMHjxYeR0bGwsAqFSpUrbfnUaNGmHatGkAgFq1auHLL79EaGgounTpkm9sj06Q9/LywqxZszBy5EgsWbIk131SUlKwatUq5UHKixcvRo8ePTB//ny4ubkBACpUqIAvv/wS5ubmqFOnDnr06IHQ0FClz2+88YbSXvXq1bFo0SK0bNkSycnJykOsa9SogYoVK+bbh4Iw5vwz5ntt+vTpeP/995WHVFevXh0zZ87EpEmTlM8ip2M/Pu3BwsICTk5OPPepzGOCVQDnz5/HgwcPsn1Jp6WloWnTpka3U7lyZSW5yI2Pjw98fHyU123atEFMTAy++OILfP/99wULvABOnDgBnU6H2rVrG5SnpqbC2dkZQGYSVq9ePWVbRkYG0tPTlX8EAOCDDz7ABx98UGRxUtnWunVrqFQq5bWfnx/mz58PnU4Hc3PzHPd5dJQjP40aNTJ47e7ubjDnLy87duzA3LlzcfbsWSQlJSEjIwMpKSl48OBBrn8UVatWTUmugMz+6PV6REVFKQlW/fr1Dfrm7u6OEydOKK+PHDmCoKAgREZG4s6dO9Dr9QAMz7fQ0FCj+lASIiMjsX//foMRK51Op7x3EydOxA8//KBse3QiO1F5xASrALK+EDZv3mzwZQoAarUaAODm5pbtDrmsu3GyvmgLq1WrVti3b1+u293c3LLd+fP4sXOrk7U9OTkZ5ubmOHLkSLZ/6LISKA8PD0RERCjlGzZswC+//ILVq1crZU5OTgCAihUrwtzcPM9jurm5IS0tDYmJiQZ/RT9ah8jW1tboupaWlgavVSqVkrDk5eLFi3j++ecxatQozJ49G05OTti3bx+GDBmCtLS0PEednySm+/fvIyAgAAEBAVi9ejVcXFwQFxeHgIAApKWlFfqYxjDm/DPmey05ORnTp0/P8eYUa2trzJgxA++88062Yz+e+GZkZOD27ds896nM4xysAqhXrx7UajXi4uJQs2ZNg5+qVasCyPzL9cSJEwZfGiEhIdBqtQajPoUREREBd3f3XLf7+fnhr7/+MrjDKiQkBD4+PqhQoYJS5/G/gkNCQpRLnk2bNoVOp8P169ez9THrC8/CwsKgvFKlStBoNAZlWQmWlZUVmjdvbnBMvV6P0NBQ5ZjNmzeHpaWlQZ2oqCjExcUpdah8eXx+zYEDB1CrVq1cR69ykjXXUKfTmSyuI0eOQK/XY/78+WjdujVq166N+Pj4fPeLi4szqHfgwAGYmZkZjELn5ezZs7h16xY+/vhjtG/fHnXq1DF6xO1JGXP+GfO91qxZM0RFRWX73qhZsybMzMxQqVIlg7KsdhMTE3HkyBGl3Z07d0Kv18PX17c4uk9UZJhgFYC9vT3eeecdTJgwAStXrkRMTAyOHj2KxYsXY+XKlQCArl27ol69enjttdcQGRmJ7du3Y8qUKRgzZowyynXlyhXUqVMn21+Ej1qwYAF+/fVXnD9/HidPnsT48eOxc+dOjBkzRqnz5ZdfolOnTsrrAQMGwMrKCkOGDMGpU6ewbt06LFy4EBMnTlTqjBs3Dtu2bcP8+fNx9uxZBAUF4fDhwxg7diwAoHbt2hg4cCBef/11bNiwAbGxsTh48CDmzp2LzZs3F+p9mzhxIr7++musXLkSZ86cwahRo3D//n1lPo2DgwOGDBmCiRMnYteuXThy5AgGDx4MPz8/tG7dulDHpNItLi4OEydORFRUFH788UcsXrwY48aNK1Abnp6eUKlU+OOPP3Djxg2TXHKqWbMm0tPTsXjxYly4cAHff/89li5dmu9+1tbWGDRoECIjI7F371689dZb6Nevn9GjMNWqVYOVlZVy3N9++w0zZ87MVq9Tp0748ssv82zr/PnziIiIwLVr1/Dw4UNEREQgIiJCGQl7/PvHmPPPmO+1qVOnYtWqVZg+fTpOnTqFM2fOYO3atZgyZUqusdatWxfdunXDsGHDcPDgQezfvx9jx47FK6+8oswBBYDTp08jIiICt2/fxt27d5U+EZVqJX0bY1mj1+tlwYIF4uPjI5aWluLi4iIBAQGyZ88epc7Fixele/fuotFopGLFivL2228b3KocGxsrAPJc+uCTTz6RGjVqiLW1tTg5OUnHjh1l586dBnWmTZsmnp6eBmWRkZHSrl07UavVUrlyZfn444+ztf3TTz9J7dq1xcrKSurXry+bN2822J6WliZTp04VLy8vsbS0FHd3d+nTp48cP348x1jzW6ZBRGTx4sVSrVo1sbKyklatWsmBAwcMtj98+FBGjx4tFSpUEBsbG+nTp49cvXo1zzapbPL395fRo0fLyJEjRavVSoUKFeSDDz7Id5mGjRs3ZmtrxowZ4ubmJiqVymCZhnHjxhnU69Wrl7I9P59//rm4u7uLRqORgIAAWbVqlcGSKbkt07BkyRLx8PAQa2treemll+T27dtKnZyWFxg3bpzBebNmzRrx8vIStVotfn5+8ttvvwkAOXbsmMH7kt+SE/7+/tmWsAAgsbGxIpLz948x519+32siItu2bZM2bdqIRqMRrVYrrVq1kuXLl+cZ761bt6R///5iZ2cnWq1WBg8ebLAsRla/c+oTUWnGhz0TET2BoKAgbNq0iSMqRGSAlwiJiIiITIwJFhE9NVavXg07O7scf+rXr1/S4RFROcJLhET01Lh3716uDxG3tLSEp6dnMUdEROUVEywiIiIiE+MlQhPLes5gQSa8BgcHZ3tMBVF51bFjR4PH0eTEy8sLCxYsKLL2iYiKGhMsKnYjRoxAjRo1oNFo4OLigl69euX76KANGzaga9eucHZ2zjOBDQsLw7PPPgtbW1totVp06NABDx8+fOKYv/rqK3h5ecHa2hq+vr45rmFWVMd+Gh06dAjDhw/Ps87u3buhUqmQmJhYPEE9duxmzZpBrVajZs2aBg9tNlZQUBBUKpXBT506dfLdb/369ahTpw6sra3RsGFDbNmyxWC7iGDq1Klwd3eHRqNB586dC/Wg9oJISUnBmDFj4OzsDDs7O7z44ovZLsXGxcWhR48esLGxQaVKlfDuu+8iIyOjSOMiKklMsKjYNW/eHCtWrMCZM2ewfft2iAi6du2a54rc9+/fR7t27fDJJ5/kWicsLAzdunVD165dcfDgQRw6dAhjx46FmdmT/ZqvW7cOEydOxLRp03D06FE0btwYAQEBBqtaF9Wxn1YuLi55Ppbm0acVFLfY2Fj06NEDzzzzDCIiIjB+/HgMHToU27dvL3Bb9evXx9WrV5WfvB6FBQB///03+vfvjyFDhuDYsWPo3bs3evfujZMnTyp15s2bh0WLFmHp0qUIDw+Hra0tAgICkJKSUuD4sgQGBiIoKCjX7RMmTMDvv/+O9evXY8+ePYiPjzd4ZI5Op0OPHj2QlpaGv//+GytXrkRwcDCmTp1a6JiISr2SW4KrbNq6dau0bdtWHBwcxMnJSXr06CHnz59Xtmct4pe1OOCuXbsEgPzxxx/SsGFDUavV4uvrKydOnFD2yVq4cNu2bVKnTh2xtbWVgIAAiY+PV+ocPHhQOnfuLM7OzqLVaqVDhw5y5MgRo+OeP3++NGjQQGxsbKRKlSoyatSobIv5LV++XKpUqSIajUZ69+4t8+fPN1hQUURk06ZN0rRpU1Gr1eLt7S1BQUHZFhssqMjISAFg8D7m5vH391G+vr4yZcqUPPePi4uTvn37ioODg1SoUEFeeOEFZQHG3LRq1UrGjBmjvNbpdOLh4SFz584t0LEpk7+/v4wZM0bGjBkjWq1WnJ2dZcqUKfkuNLpkyRLp2bOn2NjYyKBBg7ItOvnoQqNvvvmmvPvuu1KhQgVxdXXNd3HOR925c0eGDBkiFStWFHt7e3nmmWckIiJC2T5p0iSpX7++wT4vv/yyBAQEFOh9yFqgtCD69esnPXr0MCjz9fWVESNGiEjmQshubm7y6aefKtsTExNFrVbLjz/+qJQV9DwYNGhQru9hYmKiWFpayvr165WyM2fOCAAJCwsTEZEtW7aImZmZXLt2Tanzv//9T7RaraSmphrdf6KyhH9eF9D9+/cxceJEHD58GKGhoTAzM0OfPn3yfZDsu+++i/nz5+PQoUNwcXFBz549Df4Kf/DgAT777DN8//33+OuvvxAXF2fwYNR79+5h0KBB2Ldvn/Lctueeew737t0zKm4zMzMsWrQIp06dwsqVK7Fz505MmjRJ2b5//36MHDkS48aNQ0REBLp06YLZs2cbtLF37168/vrrGDduHE6fPo1ly5YhODjYoF5gYCA6duxoVExA5vu5YsUKeHt7K89zLIzr168jPDwclSpVQps2beDq6gp/f3+DEYH09HQEBATA3t4ee/fuxf79+2FnZ4du3brl+kDdtLQ0HDlyBJ07d1bKzMzM0LlzZ4SFhRl9bDK0cuVKWFhY4ODBg1i4cCE+//xzfPPNN3nuExQUhD59+uDEiROYPn06fvnlFwCZz827evUqFi5caNC+ra0twsPDMW/ePMyYMQMhISFGxda3b19cv34dW7duxZEjR9CsWTN06tQJt2/fBpA5Wvno7wMABAQEKL8PQOa8SpVKle+xoqOj4eHhgerVq2PgwIGIi4vLs35+x46NjcW1a9cM6jg4OMDX11epU5jzIC9HjhxBenq6wTHr1KmDatWqKccMCwtDw4YN4erqahB3UlISTp06VeBjEpUJJZ3hlXU3btwQAMqIVG4jWGvXrlX2uXXrlmg0Glm3bp2IZI5g4bERnK+++kpcXV1zPa5OpxN7e3v5/fffCxX3+vXrxdnZWXn98ssvZ/vLeODAgQYjWJ06dZI5c+YY1Pn+++/F3d1def3+++/La6+9lu/xv/rqK7G1tRUA4uPjY9TolUjuI1hhYWECQJycnOS7776To0ePyvjx48XKykrOnTunxOrj42MwUpKamioajUa2b9+e4/GuXLkiAOTvv/82KH/33XelVatWRh+b/uPv7y9169Y1+Bzee+89qVu3rvI6pxGs8ePHG7STdW5lPcLm0fbbtWtnUNayZUt577338o1t7969otVqJSUlxaC8Ro0asmzZMhERqVWrVrbzYPPmzQJAHjx4ICIiGzZsEB8fnzyPtWXLFvnpp58kMjJStm3bJn5+flKtWjVJSkrKdR9LS0tZs2aNQdlXX30llSpVEhGR/fv3CwCD0W8Rkb59+0q/fv1EpHDnQV4jWKtXrxYrK6ts5S1btpRJkyaJiMiwYcOka9euBtvv378vAGTLli259peoLOMIVgFFR0ejf//+qF69OrRaLby8vAAg3788s55KDwBOTk7w8fHBmTNnlDIbGxvUqFFDee3u7m4wxychIQHDhg1DrVq14ODgAK1Wi+Tk5HyPm2XHjh3o1KkTKleuDHt7e7z22mu4desWHjx4ACBzFKBVq1YG+zz+OjIyEjNmzDBYnHHYsGG4evWq0s7cuXOxatWqfOMZOHAgjh07hj179qB27dro16/fE80RyRpBHDFiBAYPHoymTZviiy++gI+PD7777jsl/vPnz8Pe3l6J38nJCSkpKYiJicHevXsN+rZ69WqTHZsMtW7d2mCEx8/PD9HR0XnOw2vRooXR7Tdq1Mjg9ePnU24iIyORnJysTNbO+omNjUVMTIzRx+/Tp0++N250794dffv2RaNGjRAQEIAtW7YgMTERP/30k9HHKYz8zgMg+4Ksq1evxpw5cwzK9u7dW6RxEpV1FiUdQFnTs2dPeHp64uuvv4aHhwf0ej0aNGhQqKH1R1laWhq8VqlUkEeWKBs0aBBu3bqFhQsXwtPTE2q1Gn5+fkYd9+LFi3j++ecxatQozJ49G05OTti3bx+GDBmCtLS0PCcTPyo5ORnTp083mLyaxdra2qg2sjg4OMDBwQG1atVC69atUaFCBWzcuBH9+/cvUDtZ3N3dAQD16tUzKK9bt66ShCYnJ6N58+Y5Jk4uLi6wsrIyuDvR1dUVarUa5ubm2e6ISkhIgJubm9HHpidna2trdN2czqf8LuMDmb8j7u7u2L17d7ZtWUupuLm55fj7oNVqodFojI4xp/Zr166N8+fP51ont2Nn/S5m/TchIUH5vcx63aRJEwD5nwcA8MILL8DX11cpf++991C5cmW89dZbSlnlypWVY6alpSExMdFguZnH43r8ztusfmTVISpvmGAVwK1btxAVFYWvv/4a7du3BwCj59kcOHAA1apVAwDcuXMH586dQ926dY0+9v79+7FkyRI899xzAIBLly7h5s2bRu175MgR6PV6zJ8/X7mr7fG/kn18fHDo0CGDssdfN2vWDFFRUahZs6bRcRtDRCAiSE1NLXQbXl5e8PDwQFRUlEH5uXPn0L17dwCZ8a9btw6VKlWCVqvNsZ2c+ta8eXOEhoaid+/eADJHrEJDQzF27Fijj02GwsPDDV5nzSs0Nzc3ug0rKysAyHPUq6CaNWuGa9euwcLCQhmdfpyfn1+2pRFCQkIMRqkLIzk5GTExMXjttddyrePn54fQ0FCDdb4ePba3tzfc3NwQGhqqJFRJSUkIDw/HqFGjABh3Htjb28Pe3t7gtZOTU67nh6WlJUJDQ/Hiiy8CyBwRj4uLU+Ly8/PD7Nmzcf36dVSqVEmJW6vVZvvDhKjcKOFLlGWKTqcTZ2dnefXVVyU6OlpCQ0OlZcuWAkA2btwoIrnPwapfv77s2LFDTpw4IS+88IJUq1ZNuXsm6y7CR23cuFEe/XiaNm0qXbp0kdOnT8uBAwekffv2otFoDOap5CYiIkIAyIIFCyQmJkZWrVollStXNpi/sm/fPjEzM5P58+fLuXPnZOnSpeLs7CyOjo5KO9u2bRMLCwsJCgqSkydPyunTp+XHH3+UDz/8UKmT3xysmJgYmTNnjhw+fFj++ecf2b9/v/Ts2VOcnJwkISFBqefj4yMbNmxQXt+6dUuOHTumzHVZu3atHDt2TK5evarU+eKLL0Sr1cr69eslOjpapkyZItbW1sr8rvv370utWrWkY8eO8tdff8mFCxdk165d8uabb8qlS5dyjXnt2rWiVqslODhYTp8+LcOHDxdHR0eDO6LyOzb9x9/fX+zs7GTChAly9uxZWbNmjdja2srSpUuVOjnNwco6x7JcvnxZVCqVBAcHy/Xr15W7Yv39/WXcuHEGdXv16qXcZZgXvV4v7dq1k8aNG8v27dslNjZW9u/fLx988IEcOnRIREQuXLggNjY28u6778qZM2fkq6++EnNzc9m2bZvSjjFzsN5++23ZvXu3cozOnTtLxYoV5fr160qd1157Td5//33l9f79+8XCwkI+++wzOXPmjEybNk0sLS0N7kr++OOPxdHRUX799Vc5fvy49OrVS7y9veXhw4ciUrjzIK85WCIiI0eOlGrVqsnOnTvl8OHD4ufnJ35+fsr2jIwMadCggXTt2lUiIiJk27Zt4uLiIpMnT87zPSIqy5hgFVBISIjUrVtX1Gq1NGrUSHbv3m1UgvX7779L/fr1xcrKSlq1aiWRkZFKm8YkWEePHpUWLVqItbW11KpVS9avX5/tH6G8fP755+Lu7i4ajUYCAgJk1apV2SYIL1++XCpXrqws0zBr1ixxc3MzaGfbtm3Spk0b0Wg0otVqpVWrVrJ8+XJl+6BBg8Tf3z/XOK5cuSLdu3eXSpUqiaWlpVSpUkUGDBggZ8+eNagHQFasWGHwHuGx2/IBZPvSnzt3rlSpUkVsbGzEz89P9u7da7D96tWr8vrrr0vFihVFrVZL9erVZdiwYXL37t0837/FixdLtWrVlM/vwIED2erkd2zK5O/vL6NHj5aRI0eKVquVChUqyAcffJDvMg2PJ1giIjNmzBA3NzdRqVQGyzQUNsESEUlKSpI333xTPDw8xNLSUqpWrSoDBw6UuLg4pc6uXbukSZMmYmVlJdWrVzf4XRX57/c1Ly+//LK4u7uLlZWVVK5cWV5++eVsCbm/v3+2uH/66SepXbu2WFlZSf369WXz5s0G2/V6vXz00Ufi6uoqarVaOnXqJFFRUQZ1Cnoe5JdgPXz4UEaPHi0VKlQQGxsb6dOnj8EfPyIiFy9elO7du4tGo5GKFSvK22+//cRLvBCVZnwWYRHbvXs3nnnmGdy5c6fMPQ5n2LBhOHv2LCezEhERFRDnYJHis88+Q5cuXWBra4utW7di5cqVWLJkSUmHRUREVOZwmYZy4PFbqh/9qV+/vtHtHDx4EF26dEHDhg2xdOlSLFq0CEOHDi3CyImKl6nOFSKi/PASYTlw7969bLduZ7G0tISnp2cxR0RUOvFcIaLiwgSLiIiIyMR4iZCIiIjIxJhgEREREZkYEywiIiIiE2OCRURERGRiTLCIiIiITIwJFhEREZGJMcEiIiIiMjEmWEREREQmxgSLiIiIyMSYYBERERGZGBMsIiIiIhNjgkVERERkYkywiIiIiEyMCRYRERGRiTHBIiIiIjIxJlhEVC4EBgbCy8urpMMoF1QqFYKCgkzSlpeXFwIDAw3KoqOj0bVrVzg4OEClUmHTpk0mORZ/B6g0YYJFRSY4OBgqlSrXnwMHDih1VSoVxo4da1S7v//+O3r27AlXV1dYWVnByckJHTp0wPz585GUlFRU3SlV5syZU+h/lAIDA2FnZ5fr9oJ8FmVRx44dc/2drFOnTkmHZ7Q1a9ZgwYIFJXb8ixcvQqVS4bPPPivwvoMGDcKJEycwe/ZsfP/992jRooXR+8bHxyMoKAgREREFPi5RcbIo6QCo/JsxYwa8vb2zldesWbNA7ej1egwZMgTBwcFo2LAhRo8ejapVq+LevXsICwvDlClTsGXLFoSGhpoq9FJrzpw5eOmll9C7d++SDqVMqlKlCubOnZut3MHBoQSiKZw1a9bg5MmTGD9+fEmHkqeoqCiYmf33t/zDhw8RFhaGDz/8sFCJfHx8PKZPnw4vLy80adLEYNvXX38NvV7/pCETmQQTLCpy3bt3L9BfqLmZN28egoODMWHCBMyfPx8qlUrZNm7cOFy9ehWrVq164uOUViKClJQUaDSakg6lRKSkpMDKysrgH+vCcnBwwKuvvmqCqCg/arXa4PWNGzcAAI6OjiY/lqWlpcnbJCosXiKkMuHBgwf45JNPUL9+fXz66acGyVUWd3d3vPfeewZlGRkZmDlzJmrUqAG1Wg0vLy988MEHSE1NNajn5eWF559/Hrt370aLFi2g0WjQsGFD7N69GwCwYcMGNGzYENbW1mjevDmOHTtmsH/WZbcLFy4gICAAtra28PDwwIwZMyAiBnX1ej0WLFiA+vXrw9raGq6urhgxYgTu3LmTY0zbt29XYlq2bBlUKhXu37+PlStXKpe2AgMDlUs2uf0UVlpaGqZOnYrmzZvDwcEBtra2aN++PXbt2mVQL69Lb8HBwQCA27dv45133kHDhg1hZ2cHrVaL7t27IzIy0qCt3bt3Q6VSYe3atZgyZQoqV64MGxsb5RLwpk2b0KBBA1hbW6NBgwbYuHFjofuXk4cPH6JOnTqoU6cOHj58qJTfvn0b7u7uaNOmDXQ6HYCi+ewBYOvWrfD394e9vT20Wi1atmyJNWvWAMh8rzdv3ox//vlHeY8fnXuUmpqKadOmoWbNmlCr1ahatSomTZqU7fc+NTUVEyZMgIuLC+zt7fHCCy/g8uXLpnobARjOwQoKCoKnpycA4N13380W95UrV/DGG2/A1dUVarUa9evXx3fffads3717N1q2bAkAGDx4cLbfr8fnYD16GfOrr75C9erVYWNjg65du+LSpUsQEcycORNVqlSBRqNBr169cPv27Wx92Lp1K9q3bw9bW1vY29ujR48eOHXqlEnfJyp/OIJFRe7u3bu4efOmQZlKpYKzs7PRbezbtw+JiYl45513YG5ubvR+Q4cOxcqVK/HSSy/h7bffRnh4OObOnYszZ85k+0f5/PnzGDBgAEaMGIFXX30Vn332GXr27ImlS5figw8+wOjRowEAc+fORb9+/bJd+tDpdOjWrRtat26NefPmYdu2bZg2bRoyMjIwY8YMpd6IESMQHByMwYMH46233kJsbCy+/PJLHDt2DPv37zf4KzwqKgr9+/fHiBEjMGzYMPj4+OD777/H0KFD0apVKwwfPhwAUKNGDbi4uOD777836FN6ejomTJgAKyurbO/N459JbpKSkvDNN9+gf//+GDZsGO7du4dvv/0WAQEBOHjwoHKZ5sMPP8TQoUMN9v3hhx+wfft2VKpUCQBw4cIFbNq0CX379oW3tzcSEhKwbNky+Pv74/Tp0/Dw8DDYf+bMmbCyssI777yD1NRUWFlZ4c8//8SLL76IevXqYe7cubh16xYGDx6MKlWqGNUfIPOzyqn/Go0Gtra20Gg0WLlyJdq2bYsPP/wQn3/+OQBgzJgxuHv3LoKDgw1+D0392QcHB+ONN95A/fr1MXnyZDg6OuLYsWPYtm0bBgwYgA8//BB3797F5cuX8cUXXwCAMq9Or9fjhRdewL59+zB8+HDUrVsXJ06cwBdffIFz584ZzN0bOnQofvjhBwwYMABt2rTBzp070aNHD6Pfx4L6v//7Pzg6OmLChAno378/nnvuOSXuhIQEtG7dWpkD6OLigq1bt2LIkCFISkrC+PHjUbduXcyYMQNTp07F8OHD0b59ewBAmzZt8jzu6tWrkZaWhjfffBO3b9/GvHnz0K9fPzz77LPYvXs33nvvPZw/fx6LFy/GO++8Y5DUff/99xg0aBACAgLwySef4MGDB/jf//6Hdu3a4dixY5xUT7kToiKyYsUKAZDjj1qtNqgLQMaMGZNrWwsXLhQAsmnTJoPyjIwMuXHjhsGPXq8XEZGIiAgBIEOHDjXY55133hEAsnPnTqXM09NTAMjff/+tlG3fvl0AiEajkX/++UcpX7ZsmQCQXbt2KWWDBg0SAPLmm28qZXq9Xnr06CFWVlZy48YNERHZu3evAJDVq1cbxLRt27Zs5Vkxbdu2Ldv7YWtrK4MGDcr1/coyevRoMTc3N+hrVqx5/Tz6WWRkZEhqaqpBu3fu3BFXV1d54403cj32/v37xdLS0qBOSkqK6HQ6g3qxsbGiVqtlxowZStmuXbsEgFSvXl0ePHhgUL9Jkybi7u4uiYmJStmff/4pAMTT0zPf98Tf3z/Xfo8YMcKg7uTJk8XMzEz++usvWb9+vQCQBQsWGNQx9WefmJgo9vb24uvrKw8fPjSom/W7LSLSo0ePHPv7/fffi5mZmezdu9egfOnSpQJA9u/fLyL/nR+jR482qDdgwAABINOmTcvtLRSRzM8NgHz66ad51vP09DT4Xc1tvyFDhoi7u7vcvHnToPyVV14RBwcH5ffg0KFDAkBWrFiR7ViDBg0yeE+yjuXi4mLw+zJ58mQBII0bN5b09HSlvH///mJlZSUpKSkiInLv3j1xdHSUYcOGGRzn2rVr4uDgkK2c6FEcwaIi99VXX6F27doGZQUZhQKgXBp6/O63EydOoGnTpgZlN27cQMWKFbFlyxYAwMSJEw22v/322/jss8+wefNmPPPMM0p5vXr14Ofnp7z29fUFADz77LOoVq1atvILFy6gY8eOBm0/Omk36y/xzZs3Y8eOHXjllVewfv16ODg4oEuXLgYjKM2bN4ednR127dqFAQMGKOXe3t4ICAjI593J2apVq7BkyRLMnz/foJ8AYG1tjd9//z3H/bp06WLw2tzcXPm89Ho9EhMTodfr0aJFCxw9ejTHNq5du4aXXnoJTZo0wZIlS5TyR+fj6HQ6JCYmws7ODj4+Pjm2NWjQIIM5Z1evXkVERATef/99gwnpXbp0Qb169XD//v3c3g4DXl5e+Prrr7OVPz4KFhQUhD/++AODBg1CcnIy/P398dZbb+XYpqk++5CQENy7dw/vv/8+rK2tDY5hzKXe9evXo27duqhTp47BcZ599lkAwK5du9CmTRvl/Hi8P+PHj1cuRRYXEcEvv/yCfv36QUQM4g4ICMDatWtx9OhRtG3btlDt9+3b1+D3JescfvXVV2FhYWFQ/uOPP+LKlSuoXr06QkJCkJiYiP79+xvEZG5uDl9f32yXyYkexQSLilyrVq2eeJK7vb09ACA5OdmgvGbNmggJCQGQmVA8eonsn3/+gZmZWba7Fd3c3ODo6Ih//vnHoPzRJAr4746yqlWr5lj++LwZMzMzVK9e3aAsK7G8ePEigMz1f+7evatcMnvc9evXDV7ndPelMSIiIjBy5Ej0798/W4IJZP4D0blzZ6PbW7lyJebPn4+zZ88iPT09z/gyMjLQr18/6HQ6bNiwwSCp0uv1WLhwIZYsWYLY2FhlHhOAHC8ZP95+1mdWq1atbHVzS9JyYmtra1T/rays8N1336Fly5awtrbGihUrckxyTPnZx8TEAAAaNGhgVF8eFx0djTNnzsDFxSXP42SdHzVq1DDY7uPjU6jjPokbN24gMTERy5cvx/Lly3Os8/i5URCFPbejo6MB/JecPk6r1RY6Jir/mGBRmZC1PtHJkyfRq1cvpdzOzk75h3Lfvn057mvsBO/cRtVyK5fHJjAbQ6/Xo1KlSli9enWO2x//R7EwdwzeuXMHL774ImrXro1vvvmmwPs/7ocffkBgYCB69+6Nd999F5UqVYK5uTnmzp2rJAOPevfddxEWFoYdO3ZkGxGaM2cOPvroI7zxxhuYOXMmnJycYGZmhvHjx+d4e31puGNy+/btADLvYoyOji500lvQz76w9Ho9GjZsqMwbe9zjSUVpkPXZv/rqqxg0aFCOdRo1alTo9gt7bmfF9f3338PNzS1bvUdHv4gex98OKhPat28PBwcHrF27FpMnTzbqVn1PT0/o9XpER0ejbt26SnlCQgISExOVu5lMRa/X48KFCwaXQ8+dOwcAykTYGjVqYMeOHWjbtu0TJQ+5JY16vR4DBw5EYmIiduzYARsbm0IfI8vPP/+M6tWrY8OGDQbHnTZtWra6a9euxYIFC7BgwQL4+/vn2NYzzzyDb7/91qA8MTERFStWzDeWrM8sa2ThUVFRUfnuX1DHjx/HjBkzMHjwYERERGDo0KE4ceJEtvWyTPnZZ40onTx5Ms+14nL7HahRowYiIyPRqVOnPP+4yDo/YmJiDEatiuJ9zE/WXYw6nS7fkcUnuSO2oLI+i0qVKhVoxJcI4DINVEbY2Nhg0qRJOHnyJN5///0cR48eL3vuuecAINtq11l/2RfF3VJffvmlQTxffvklLC0t0alTJwBQLp3NnDkz274ZGRlITEw06ji2trY51p0+fTq2b9+OH3/8sdAjLY/L+iv/0fc3PDwcYWFhBvVOnjyJoUOH4tVXX8W4ceNybevxz2n9+vW4cuWKUbG4u7ujSZMmWLlyJe7evauUh4SE4PTp00a1Yaz09HQEBgbCw8MDCxcuRHBwMBISEjBhwoQc65vqs+/atSvs7e0xd+5cpKSkGNR79L2ztbU1eA+y9OvXD1euXMlxjtnDhw+VeWrdu3cHACxatMigTkmsDm9ubo4XX3wRv/zyC06ePJlte9baWUBmvwEYfa48iYCAAGi1WsyZM8fg0nhOcRE9jiNYVOS2bt2Ks2fPZitv06aNwbyVw4cPY9asWdnqdezYEe3atcP777+PM2fO4NNPP1Vu1a9SpQru3LmDo0ePYv369ahUqZIyMbhx48YYNGgQli9fjsTERPj7++PgwYNYuXIlevfunW3i95OytrbGtm3bMGjQIPj6+mLr1q3YvHkzPvjgA+Xyj7+/P0aMGIG5c+ciIiICXbt2haWlJaKjo7F+/XosXLgQL730Ur7Hat68OXbs2IHPP/8cHh4e8Pb2ho2NDWbOnIkOHTrg+vXr+OGHHwz2KezCms8//zw2bNiAPn36oEePHoiNjcXSpUtRr149gzlxgwcPBgB06NAh27GzPuvnn39eGRFq06YNTpw4gdWrV2ebv5SXuXPnokePHmjXrh3eeOMN3L59G4sXL0b9+vWzzdHLzd27d7PFmCXrfZo1axYiIiIQGhoKe3t7NGrUCFOnTsWUKVPw0ksvKQk8YNrPXqvV4osvvsDQoUPRsmVLDBgwABUqVEBkZCQePHiAlStXAsj8HVi3bh0mTpyIli1bws7ODj179sRrr72Gn376CSNHjsSuXbvQtm1b6HQ6nD17Fj/99JOyrlqTJk3Qv39/LFmyBHfv3kWbNm0QGhqK8+fPG/1ZAEBoaGi2RBAAevfuXaB5ZB9//DF27doFX19fDBs2DPXq1cPt27dx9OhR7NixQ1mfqkaNGnB0dMTSpUthb28PW1tb+Pr6muwPikdptVr873//w2uvvYZmzZrhlVdegYuLC+Li4rB582a0bdvWILEmMlBCdy/SUyCvZRrw2G3WedWbOXOmQbsbN26U5557TlxcXMTCwkIcHR2lXbt28umnnxrcii0ikp6eLtOnTxdvb2+xtLSUqlWryuTJk5XbsLN4enpKjx49svUBOSwfkdNt5oMGDRJbW1uJiYmRrl27io2Njbi6usq0adOyLUsgIrJ8+XJp3ry5aDQasbe3l4YNG8qkSZMkPj4+35hERM6ePSsdOnQQjUYjAGTQoEHK0ga5/Twea24e77Ner5c5c+aIp6enqNVqadq0qfzxxx/ZbonPWlYir886JSVF3n77bXF3dxeNRiNt27aVsLAw8ff3F39/f6WtrL6sX78+xxh/+eUXqVu3rqjVaqlXr55s2LAhWzy5yWuZhqz36ciRI2JhYWGw9IJI5pIVLVu2FA8PD7lz547B+2nKz15E5LfffpM2bdqIRqMRrVYrrVq1kh9//FHZnpycLAMGDBBHR8dsS1SkpaXJJ598IvXr1xe1Wi0VKlSQ5s2by/Tp0+Xu3btKvYcPH8pbb70lzs7OYmtrKz179pRLly4VaJmG3H6+//57ETF+mQYRkYSEBBkzZoxUrVpVLC0txc3NTTp16iTLly83qPfrr79KvXr1xMLCwuD3K7dlGh4/Vm6/X1nfWYcOHcpWPyAgQBwcHMTa2lpq1KghgYGBcvjw4TzfI3q6qUQKMVOXiAwEBgbi559/NnoEhcoPfvZElBPOwSIiIiIyMSZYRERERCbGBIuIiIjIxDgHi4iIiMjEOIJFREREZGJMsIiIiIhMjAuNGkmv1yM+Ph729vbF+qgGIiKisk5EcO/ePXh4eBj1qLPygAmWkeLj40vlQ1KJiIjKikuXLmV7CHx5xQTLSPb29gAyfzm0Wq1J2kxPT8eff/6pPDKjPGCfygb2qfQrb/0B2Keyoij6lJSUhKpVqyr/lj4NmGAZKeuyoFarNWmCZWNjA61WW65OTPap9GOfSr/y1h+AfSorirJPT9MUm6fjQigRERFRMWKCRURERGRiTLCIiIiITIwJFhEREZGJMcEiIiIiMjEmWEREREQmxgSLiIiIyMSYYBERERGZGBMsIiIiIhNjgkVERERkYkywiIiIiEyMCRYRERGRiTHBIiIiIjIxJlhEREREJsYEi4iIiMjELEo6ACIiotJCrxekpwrSUgTpKYLUh4/8f4ogPQVISxWkPRTo9QK9TofLp12xP+UhIGlISxHlJz1V8j1eRtq/9R8K0lIFuown7IAAGRmZ8WbFoUsvaBMCM6vGeO65J4zlKccEi4iIypW0VEHyHT2SE/VIvqPH/UQ9Uh/okZYKpD3M/O/De/9uT9Tj/h09HiTrkfZQkJ5amCN64XzoA1N3o0RZqniB60kxwSIiojLlYbIet6/qcCdBh9vXdLhzVYfbCTql7H5i/iNHxrBUA1bWKlhZq2D573/VGhUs1Zn/b26hgl6vR/zVq/Bwd4e5hVlmfY0KamsVLKxUUKnyPoaFZWZ9S2sVrNQqmFs+edwWFv+2928cBW0zIyMDe/bsAuD+5ME8xZhgERFRqfQwWY/L59Jx9UIGEi5m/ly7mGFUAmVuCdg5msHO0Qy2jmawtv03Qfo3WdLYZZZn1bHR/ps8ZSVUahXMzPLJjgCkp6djy5a9eO652rC0NEF2VAqkpwusHdJKOowyjwkWERGVuNQHelyOzsCls+nKz41Lulzr2zqqUMHVHE7u5nByNUcFt8z/r+Ca+aOxV0GV3/ARURFigkVERMXu7k0dzoan4vzRNFyKSsf1f3SQHAamnNzN4VHTAm5eFnDztoCrlwVcqphDbcM5QlS6McEiIqIiJyL453Q6YvZUxRcbEnE1JvvolGMlM1T1sUTVupaoWscSVX0sYevARIrKJiZYRERUZG5eycDh7Sk48udD3LysA+ABQAeVCqhaxxI+La3g2SAzmdI6m5d0uEQmwwSLiIhMKi1FELErBQd+e4DYE/8twmRpDVTwvolO/+eFeq1tYFeBo1NUfjHBIiIik7h6IR1hvz3E4W0P8TA5c0KVygyo3cIKLQI0qONnjtBd4Wja2QeWlkyuqHxjgkVERE8kJjINO1Yl42z4f7f2O7mbo3VPDVo9p4FDxcxLf+npBVxSnKgMY4JFREQFJiI4eyANId8nI/Z4ZuKkMgMatlfDr5cNarewMmodKaLyigkWEREVyI1LGVj/WRKij2SOWJlbAq26a/DsQFtUrMx/VogAJlhERGSkjHTBrjX38efKZGSkAZZWQNs+NujY31a5DEhEmZhgERFRvv45lYa1HyfhWmwGAKB2Syv0fUfLESuiXPDMICKiXOn1maNWW75Ohl6X+Xy/3m/Zo1kXaz6KhigPTLCIiChH927rsHrWXUQdzJxr1bSTNV58WwtbLZdYIMoPEywiIsrm3OFU/DDzLu7d0sNSDfzfeC18n9dw1IrISEywiIjIwN5f7mPjwnsQPeDmbYHXpzvAvbplSYdFVKYUyTjvlStX8Oqrr8LZ2RkajQYNGzbE4cOHi+JQiq+++gpeXl6wtraGr68vDh48mGM9EUH37t2hUqmwadOmIo2JiKgs0WUIfp6fhA1fZCZXLbpZY8LXzkyuiArB5AnWnTt30LZtW1haWmLr1q04ffo05s+fjwoVKhS6zeDgYHTs2DHX7evWrcPEiRMxbdo0HD16FI0bN0ZAQACuX7+ere6CBQs4xE1E9JiH9/T4etId7N/4ACoV8PwoOwz40AFW1vy+JCoMkydYn3zyCapWrYoVK1agVatW8Pb2RteuXVGjRg2lTmpqKt555x1UrlwZtra28PX1xe7duwt9zM8//xzDhg3D4MGDUa9ePSxduhQ2Njb47rvvDOpFRERg/vz52cqJiJ5md2/qsHDULUQdTIOVtQqBsxzRaaAd/xglegImn4P122+/ISAgAH379sWePXtQuXJljB49GsOGDVPqjB07FqdPn8batWvh4eGBjRs3olu3bjhx4gRq1apVoOOlpaXhyJEjmDx5slJmZmaGzp07IywsTCl78OABBgwYgK+++gpubm75tpuamorU1FTldVJSEoDMZ2mZ6nlaWe2Up+dzsU9lA/tU+hVXf+7f1WPpuCQk/KODQ0UzBM6xR+Va5kVy3PL2GQHsU0HbfJqoRERM2aC1tTUAYOLEiejbty8OHTqEcePGYenSpRg0aBDi4uJQvXp1xMXFwcPDQ9mvc+fOaNWqFebMmZOtzeDgYAQHB+c4yhUfH4/KlSvj77//hp+fn1I+adIk7NmzB+Hh4QCAESNGQKfT4ZtvvsnsuEqFjRs3onfv3jn2IygoCNOnT89WvmbNGtjY2Bj9fhARlVYZqeaIWFcHyQl2sLJLQ9P+p6FxTM1/R6ICyhrkuHv3LrRabUmHUyxMPoKl1+vRokULJVFq2rQpTp48qSRYJ06cgE6nQ+3atQ32S01NhbOzMwAgLi4O9erVU7ZlZGQgPT0ddnZ2StkHH3yADz74wKiYfvvtN+zcuRPHjh0zuh+TJ0/GxIkTlddJSUmoWrUqunbtarJfjvT0dISEhKBLly6wtCwfk0jZp7KBfSr9iro/aQ8F37yXhOSEDNg6qDByoQtcPTuZ/DiPKm+fEcA+GSvrKtDTxOQJlru7u0FyBAB169bFL7/8AgBITk6Gubk5jhw5AnNzw2dXZSVQHh4eiIiIUMo3bNiAX375BatXr1bKnJycAAAVK1aEubk5EhISDNpKSEhQLgXu3LkTMTExcHR0NKjz4osvon379jmOjKnVaqjV6mzllpaWJj+JiqLNksY+lQ3sU+lXFP3JSBN8H3QHF09kwNpOhZFfOKFKzeJ7z8rbZwSwT8a09bQxeYLVtm1bREVFGZSdO3cOnp6eADJHtHQ6Ha5fv4727dvnHJSFBWrWrKm8rlSpEjQajUFZFisrKzRv3hyhoaHK5T69Xo/Q0FCMHTsWAPD+++9j6NChBvs1bNgQX3zxBXr27FnovhIRlUU/f56UOaFdo8KIzyqgSu2n7x8/oqJm8gRrwoQJaNOmDebMmYN+/frh4MGDWL58OZYvXw4AqF27NgYOHIjXX38d8+fPR9OmTXHjxg2EhoaiUaNG6NGjR4GPOXHiRAwaNAgtWrRAq1atsGDBAty/fx+DBw8GALi5ueU4sb1atWrw9vZ+sg4TEZUhB/54gPA/HkKlAgbPcoRXA6uSDomoXDJ5gtWyZUts3LgRkydPxowZM+Dt7Y0FCxZg4MCBSp0VK1Zg1qxZePvtt3HlyhVUrFgRrVu3xvPPP1+oY7788su4ceMGpk6dimvXrqFJkybYtm0bXF1dTdUtIqIy71JUOn75PHMuTPehdqjjm30aBBGZRpE8Kuf555/PM1mytLTE9OnTc7xLLyeBgYEIDAzMs87YsWOVS4LGMPHNk0REpdr9JD2CpyQiIw2o10aNTq/ZlnRIROUaH4lORFTO6fWCNbPu4vZVHZw9zDFwigPMzLiIKFFRYoJFRFTO7Vx9H6f/ToWlFTB4tiNstPzqJypqPMuIiMqxK9Hp2PZtMgDgxYlaVK7FOwaJigMTLCKiciojPfPSoC4DaNhBjVY9NCUdEtFTgwkWEVE59eeKZMTHZMDWUYW+72r58GaiYsQEi4ioHPrnVBp2/HAfAND3HQfYVzDPZw8iMiUmWERE5UxaqmDN7LsQPdCsizUad7Qu6ZCInjpMsIiIypmty+/hepwOWmcz/N8E0zycnogKhgkWEVE5ci02A3vWPwAA9HtPC1suyUBUInjmERGVI78tuQfRAw3bq1G/DS8NEpUUJlhEROXE2YOpOBOWCjNzoOdo+5IOh+ipxgSLiKgc0OsEv315DwDQ7kUbuFQtkkfNEpGRmGAREZUD4Zsf4uqFDNjYq9A10K6kwyF66jHBIiIq41Ie6LH1m8zH4XQdbMeJ7USlAM9CIqIybucP93Hvth4Vq5ijbR+bkg6HiMAEi4ioTLt7U4fdazNXbH9htD0sLPk4HKLSgAkWEVEZtmfdfaSnAV4NLdGgvbqkwyGifzHBIiIqox4k6fH3pocAgM6v2fJhzkSlCBMsIqIyat+GB0h9KHCvYYF6fhy9IipNmGAREZVBaSmCv37OnHvVaSBHr4hKGyZYRERl0IHfH+B+osDZwxxNnuUjcYhKGyZYRERlTEa6YNePmaNXzwywhbkFR6+IShsmWEREZczRkIdIvK6HvbMZWnXXlHQ4RJQDJlhERGWIXi8IXZ05euXfzwaWao5eEZVGTLCIiMqQU/tTcf0fHaztVGjbm6u2E5VWTLCIiMqQ/RsfAAD8XrCBtS2/wolKK56dRERlxI3LGYg6mAaVCmjTi3OviEozJlhERGVE2G+Zq7b7tLJCxcoWJRwNEeWFCRYRURmQnio4uDnz8mAbzr0iKvWYYBERlQHH96Tg/l2BYyUzPhaHqAxggkVEVAY8OrmdC4sSlX5MsIiISrn4mHTEnkiHmTng+zwntxOVBUywiIhKub83ZU5ub9BeDYeK5iUcDREZgwkWEVEplvpQcHh7ZoLFhUWJyg4mWEREpdixHalIfSBwqWKOms2sSjocIjISEywiolLsyPZUAJmT283MOLmdqKxggkVEVEo9TFTjn1MZUKmAZl2tSzocIioAJlhERKXU9bPOAICazaw4uZ2ojGGCRURUCokIEk5nJljNu3D0iqisYYJFRFQKXbugw4NbNjC3BBr5M8EiKmuYYBERlULHQjMnt9dtbQWNPb+qicoanrVERKWMXi+I2JkGAGjaiUszEJVFTLCIiEqZ2BPpSEzQw9wqA3VaM8EiKouYYBERlTJHQzJXbnepfQeWaq59RVQWMcEiIipFMtIFETtTAACV6t4s4WiIqLCYYBERlSJRh1LxIElgV0GFCtWSSjocIiokJlhERKXI0ZDM0asmz6qh4jc0UZnF05eIqJTISBOc2pe5PEPjZzm5nagsY4JFRFRKRB9NQ+pDgdbZDFXrWJR0OET0BEyeYAUFBUGlUhn81KlTx9SHUYgIpk6dCnd3d2g0GnTu3BnR0dE51k1NTUWTJk2gUqkQERFRZDERERXGyX2Zlwfrt1PDzIx3DxKVZUUyglW/fn1cvXpV+dm3b1+h2woKCkJgYGCu2+fNm4dFixZh6dKlCA8Ph62tLQICApCSkpKt7qRJk+Dh4VHoWIiIiope/9/lwYbt+WgcorKuSBIsCwsLuLm5KT8VK1ZUtiUmJmLo0KFwcXGBVqvFs88+i8jIyEIdR0SwYMECTJkyBb169UKjRo2watUqxMfHY9OmTQZ1t27dij///BOfffbZk3SNiKhIXDqbjrs39VDbqFCrGedfEZV1RXKRPzo6Gh4eHrC2toafnx/mzp2LatWqAQD69u0LjUaDrVu3wsHBAcuWLUOnTp1w7tw5ODk5Feg4sbGxuHbtGjp37qyUOTg4wNfXF2FhYXjllVcAAAkJCRg2bBg2bdoEGxsbo9pOTU1Famqq8jopKfN26fT0dKSnpxcoztxktWOq9koD9qlsYJ9Kn+N7MhcX9WlpCVFllPn+5IR9KhuKok/l6f0xlkpExJQNbt26FcnJyfDx8cHVq1cxffp0XLlyBSdPnkRkZCR69OiB69evQ61WK/vUrFkTkyZNwvDhw7O1FxQUhIsXLyI4ODjbtr///htt27ZFfHw83N3dlfJ+/fpBpVJh3bp1EBE899xzaNu2LaZMmYKLFy/C29sbx44dQ5MmTXLtR1BQEKZPn56tfM2aNUYnaURExjq4oiEe3LRB3R7n4VrvVkmHQ2RSDx48wIABA3D37l1otdqSDqdYmHwEq3v37sr/N2rUCL6+vvD09MRPP/2ElJQUJCcnw9nZ2WCfhw8fIiYmBgCwd+9egzbS0tIgIvj555+VsmXLlmHgwIFGxbN48WLcu3cPkydPLlA/Jk+ejIkTJyqvk5KSULVqVXTt2tVkvxzp6ekICQlBly5dYGlpaZI2Sxr7VDawT6XLrSs67L6ZCDNz4OURLWFjb1am+5Mb9qlsKIo+ZV0FepoU+X3Ajo6OqF27Ns6fPw9HR0e4u7tj9+7dOdYDgBYtWhjc4bdo0SJcuXIFn3zyiVLm6uoKAHBzcwOQeQnw0RGshIQEZXRq586dCAsLMxgxyzrOwIEDsXLlyhzjVqvV2fYBAEtLS5OfREXRZkljn8oG9ql0OHsgDQBQo4kVHJwMv3fKYn/ywz6VDabsU3l7b4xR5AlWcnIyYmJi8Nprr6Fu3bq4du0aLCws4OXllWN9jUaDmjVrKq+dnJyQlJRkUJbF29sbbm5uCA0NVRKqpKQkhIeHY9SoUQAyE7RZs2Yp+8THxyMgIADr1q2Dr6+v6TpKRFRIJ/Zm3vXcoH32P+qIqGwyeYL1zjvvoGfPnvD09ER8fDymTZsGc3Nz9O/fHxUrVoSfnx969+6NefPmoXbt2oiPj8fmzZvRp08ftGjRokDHUqlUGD9+PGbNmoVatWrB29sbH330ETw8PNC7d28AUCbXZ7GzswMA1KhRA1WqVDFJn4mICis5UY/YE5kTgBu04/IMROWFyROsy5cvo3///rh16xZcXFzQrl07HDhwAC4uLgCALVu24MMPP8TgwYNx48YNuLm5oUOHDsplv4KaNGkS7t+/j+HDhyMxMRHt2rXDtm3bYG3NLyoiKv1O/50C0QOVa1nAyc28pMMhIhMxeYK1du3aPLfb29tj0aJFWLRokVHtBQUF5bldpVJhxowZmDFjhlHteXl5wcQ3ThIRFdrJvZnLwTTg4qJE5QqfRUhEVELSUwVRhzInuDfk/CuicoUJFhFRCblwPA1pKQKHimbwqMmHOxOVJ0ywiIhKSNbolU8rNVQqPtyZqDxhgkVEVELOHcqcf+XTks8eJCpvmGAREZWAe7d1uBKdAQCo1YIJFlF5wwSLiKgEnDuceXmwcm0L2Ffg8gxE5Q0TLCKiEhCVdXmwBe8eJCqPmGARERUzEUHUwawJ7rw8SFQeMcEiIipm12IzkHRLD0srwLshEyyi8ogJFhFRMctanqFGEytYqrk8A1F5xASLiKiYKcsztOL8K6LyigkWEVExykgTnD+WOYJVm+tfEZVbTLCIiIpR7Ik0pKcC9s5mcK/Ox+MQlVdMsIiIipHyeJwWVnw8DlE5xgSLiKgYRR3k/CuipwETLCKiYpJ8R688Hqc2H49DVK4xwSIiKibnj6VBBHCvYQGtMx+PQ1SeMcEiIiomMRGZ869qNuXoFVF5xwSLiKiYZCVYNZowwSIq75hgEREVg+REPa5eyJx/VaMxEyyi8o4JFhFRMbgQmTl65eplAbsK/OolKu94lhMRFQNl/lUTyxKOhIiKAxMsIqJiEPPvCFYNTnAneiowwSIiKmIP7+kR/+/6V9U5/4roqcAEi4ioiF04nrn+lUsVczhU5PpXRE8DJlhEREVMWZ6BlweJnhpMsIiIilhMRDoArn9F9DRhgkVEVIRSHuhx+RwTLKKnjUVqaiqOHj2K69evo23btqhYsWJJx0REVG5cPJEOvQ5wcjdHBVfOvyJ6Wpi5u7ujXbt2+L//+z8cP34cAHDz5k1UrFgR3333XQmHR0RUtv33eByuf0X0NDHr1q0bvv32W4iIUlixYkU8++yzWLt2bQmGRkRU9p3n8weJnkpma9asQc+ePbNtaN68OU6dOlUCIRERlQ9pKYJLZzj/iuhplOskdycnJ9y6das4YyEiKlcunkyDLgNwrGQGZw/OvyJ6muSaYJ0+fRpubm7FGQsRUbmS9YDn6o2toFKpSjgaIipOZomJidkKT506ha+//hovvPBC8UdERFROxJ7MvDxYvREvDxI9bSwaNGiAnj17QqVSYeXKlfjuu+/wyy+/wN3dHVOnTi3p+IiIyiS9XhB3OjPB8mrAOwiJnjZm3bp1w7p16yAi+P777/H777+jf//+OHDgANfEIiIqpISLGUi5L7DSqODmbVHS4RBRMbP45ptv8M033+DGjRvQ6/VwcXGBmRkXeCciehKxJzJHrzzrWcLcgvOviJ42yp9VLi4uJRkHEVG58s+pfy8P1uflQaKnkcWqVatw4cIF3Llzx2CxUQBQqVRYuHBhCYVGRFR2XTyZeQehJ+dfET2VLAIDA3PdyASLiKjg7t/V43qcDgDgVZ93EBI9jcy2b9+OxMRE6PX6bD86na6k4yMiKnMunsocvapUzRy2DpzTSvQ0sujSpUtJx0BEVK78czJreQaOXhE9rfinFRGRiV38d4K7Jye4Ez21zA4fPlzSMRARlRu6jP8WGPVuyASL6Gll4efnh7p166Jq1aowNzd8GKlKpcKvv/5aQqEREZU912IzkPpQYG2rgqsXFxglelpZ6HQ6XL58Gffu3cu2kQ8nJSIqmIv/zr+qVs8SZmb8DiV6WlmcPXsWtWvXLuk4iIjKhaz1r/j8QaKnmxmTKyIi08ma4O7NOwiJnmpFfhfhxx9/DJVKhfHjxxfZMUQEU6dOhbu7OzQaDTp37ozo6Ogc66ampqJJkyZQqVSIiIgospiI6Olz744ONy9nrh/oWY8jWERPM7OffvqpyBo/dOgQli1bhkaNGj1RO0FBQchrxfl58+Zh0aJFWLp0KcLDw2Fra4uAgACkpKRkqztp0iR4eHg8UTxERDnJev6gq5cFNPZcBYfoaWbWv39/ODg4oH79+mjUqJHBT+PGjQvdcHJyMgYOHIivv/4aFSpUMNiWmJiIoUOHwsXFBVqtFs8++ywiIyMLdRwRwYIFCzBlyhT06tULjRo1wqpVqxAfH49NmzYZ1N26dSv+/PNPfPbZZ4XtFhFRri4qC4xy9IroaWfRoUOHIml4zJgx6NGjBzp37oxZs2YZbOvbty80Gg22bt0KBwcHLFu2DJ06dcK5c+fg5ORUoOPExsbi2rVr6Ny5s1Lm4OAAX19fhIWF4ZVXXgEAJCQkYNiwYdi0aRNsbGzybTc1NRWpqanK66SkJABAeno60tPTCxRjbrLaMVV7pQH7VDawT0Uj9mTmd0bVOmZPHEdp6I+psU9lQ1H0qTy9P8ay2LVrl8kbXbt2LY4ePYpDhw5l27Zv3z4cPHgQ169fh1qtBgB89tln2LRpE37++WcMHz68QMe6du0aAMDV1dWg3NXVVdkmIggMDMTIkSPRokULXLx4Md92586di+nTp2cr//PPP41K0AoiJCTEpO2VBuxT2cA+mY7ogX9OtQBgjos3w3Bzy0OTtMvPqGxgn/L24MEDk7VVVph8FbxLly5h3LhxCAkJgbW1dbbtkZGRSE5OhrOzs0H5w4cPERMTAwDYu3cvunfvrmxLS0uDiODnn39WypYtW4aBAwcaFdPixYtx7949TJ482eh+TJ48GRMnTlReJyUloWrVqujatSu0Wq3R7eQlPT0dISEh6NKlCywty8clBfapbGCfTC/hYgb2pN+FlTXw0qsdYWb+ZGtglXR/igL7VDYURZ+yrgI9TSz++uuvPCsU9BLikSNHcP36dTRr1kwp0+l0+Ouvv/Dll19i9uzZcHd3x+7du7Pt6+joCABo0aKFwR1+ixYtwpUrV/DJJ58oZVkjVm5ubgAyLwG6u7sr2xMSEtCkSRMAwM6dOxEWFqaMmGVp0aIFBg4ciJUrV2aLRa1WZ6sPAJaWliY/iYqizZLGPpUN7JPpxEdnXgKpWscSamvTLdHAz6hsYJ/yb+tpY/HMM8/kuEFEoFKpoNPpCtRgp06dcOLECYOywYMHo06dOnjvvfdw9epVXLt2DRYWFvDy8sqxDY1Gg5o1ayqvnZyckJSUZFCWxdvbG25ubggNDVUSqqSkJISHh2PUqFEAMhO0R+eBxcfHIyAgAOvWrYOvr2+B+kdElJO4MxkAMhMsIiKLnTt3mrRBe3t7NGjQwKDM1tYWzs7OaNCgAerXrw8/Pz/07t0b8+bNQ+3atREfH4/NmzejT58+aNGiRYGOl7XG1qxZs1CrVi14e3vjo48+goeHB3r37g0AqFatmsE+dnZ2AIAaNWqgSpUqhe8sEdG/4s5kruBerS4TLCICLPz9/Yv1gCqVClu2bMGHH36IwYMH48aNG3Bzc0OHDh2yTVQ31qRJk3D//n0MHz4ciYmJaNeuHbZt25bjHDAiIlPLSBPEn88cwWKCRURAHpPcd+3ahZkzZ8IUI1yPz7eyt7fHokWLsGjRIqP2DwoKynO7SqXCjBkzMGPGDKPa8/LygogYVZeIKD/xMRnQZQC2Dio4uZuXdDhEVArkutTw9evXsWfPnuKMhYioTIo7/d/lQZXqye4eJKLyIdcE6/z587C3ty/OWIiIyqS4s//eQcjLg0T0L4tnn302W2FiYiKOHz+O5557rgRCIiIqW+LOZCZY1XgHIRH9y+LGjRsGBSqVCra2thg5ciSmTp1aQmEREZUNKff1uP5P5nI2nOBORFksHl+zioiIjHcpKh0iQAVXM9g7cYI7EWXKdQ4WERHlL+vyIOdfEdGjzNauXYsRI0agT58+ygrsd+/exYYNG5CQkFDC4RERlW6XsuZfMcEiokeYDRgwAD/++CN+++03ZM3HsrOzw1tvvYWFCxeWcHhERKVbHBMsIsqB2fbt23HhwgWDhTfNzc3x0ksvYcuWLSUYGhFR6Xbvtg53EvRQqYCqPkywiOg/Zl26dMlxYbzatWvj4sWLxR8REVEZkTV6VcnTHNa2nNJKRP/J9RshPT0dGRkZxRkLEVGZoiwwyvWviOgxuSZYf/75J+rVq1ecsRARlSlxpzMTLE/OvyKix5itW7dOmX+lUqmQmpqKDz/8ENu2bcOIESNKODwiotJJRHApiks0EFHOLPr37w9HR0cAwIABA3Dr1i1kZGRgxIgRGDJkSMlGR0RUSt1J0ON+osDMHPCowQSLiAxZ/PXXX/j5558RHR0NvV6PGjVqoF+/fujQoUNJx0ZEVGpd+nf+lXt1C1iqs98oRERPN4t27dqhXbt2JR0HEVGZcjmKE9yJKHe8r5iIqBCy5l9V4fpXRJQDJlhERAUkIv+NYDHBIqIcWDRq1CjXjSqVCpGRkcUYDhFR6XcnQY/7dzMnuLtXtyjpcIioFLJwdnYu6RiIiMoUTnAnovxY7Nq1q6RjICIqUzjBnYjywzlYREQFxAnuRJQfJlhERAXACe5EZAwLc3PzXDeqVCo+8JmI6BGc4E5ExrCYOnVqScdARFRmcII7ERnDYtq0aSUdAxFRmcEJ7kRkjFznYK1ZswZdu3YtzliIiEo9TnAnImPkmmDFxsYiNDS0OGMhIirVOMGdiIzFuwiJiIzECe5EZCwmWERERuIEdyIyFhMsIiIjcYI7ERmLCRYRkZE4wZ2IjGXRqFGjHDdcv369mEMhIiq9OMGdiArCwtnZOccNzs7OqFu3bjGHQ0RUOnGCOxEVhMWuXbtKOgYiolIva/TKzZsT3Ikof5yDRURkBF4eJKKCYIJFRGSEy+f+neBem5cHiSh/TLCIiPIhIrgUlQGAdxASkXGYYBER5SPplh7Jd/RQmQEeNZlgEVH+mGAREeUja/6Vq6cFrKw5wZ2I8scEi4goH5fP/Xt5kPOviMhITLCIiPKhTHDn/CsiMpJF9erVc92oUqkQExNTjOEQEZU+WZcIq9RmgkVExjG7ePEibGxs0LRpUzRt2hQ2Nja4ePEi7Ozs0KFDh5KOj4ioRCXf0SPxuh4AULkWLxESkXEsQkJC0KlTJ4PCkJAQ9OvXDzNnziyhsIiISofL0ZmjVy5VzGFty1kVRGQcs8eTKwDo0qULxo4diylTppRASEREpYdyeZDzr4ioAHL9c8zZ2Znzr4joqZd1B2Fl3kFIRAVglpycnK3w3r17+O6775DXBHgioqfBlXOc4E5EBWdRp04dBAYGombNmgCA6OhorFy5EgkJCVi/fn0Jh0dEVHIe3tPj5hUdACZYRFQwZi4uLpgzZw7eeOMNvPHGG5g7dy4qVaqEP/74A7179y5wg//73//QqFEjaLVaaLVa+Pn5YevWraaP/F8igqlTp8Ld3R0ajQadO3dGdHR0jnVTU1PRpEkTqFQqREREFFlMRFQ+ZE1wd3I3h60DJ7gTkfHMjh07hvj4eISFhSEsLAzx8fE4evQoAgICCtVglSpV8PHHH+PIkSM4fPgwnn32WfTq1QunTp0qVHtBQUEIDAzMdfu8efOwaNEiLF26FOHh4bC1tUVAQABSUlKy1Z00aRI8PDwKFQcRPX0uR3EFdyIqHDMAcHNzg6+vL3x9feHm5vZEDfbs2RPPPfccatWqhdq1a2P27Nmws7PDgQMHAACJiYkYOnQoXFxcoNVq8eyzzyIyMrJQxxIRLFiwAFOmTEGvXr3QqFEjrFq1CvHx8di0aZNB3a1bt+LPP//EZ5999kT9I6Knx2XOvyKiQrIYOXIkdu3ahRs3bmDTpk3o0KEDbt68iRkzZmDw4MFo2rRpoRvX6XRYv3497t+/Dz8/PwBA3759odFosHXrVjg4OGDZsmXo1KkTzp07BycnpwK1Hxsbi2vXrqFz585KmYODA3x9fREWFoZXXnkFAJCQkIBhw4Zh06ZNsLGxMart1NRUpKamKq+TkpIAAOnp6UhPTy9QnLnJasdU7ZUG7FPZwD4ZJ2uJBrcaqmJ/r/gZlQ3sU8HafJpYrFu3Dr6+vjh//jwyMjKHwytWrIh9+/bh/v37+Pbbbwvc6IkTJ+Dn54eUlBTY2dlh48aNqFevHvbt24eDBw/i+vXrUKvVAIDPPvsMmzZtws8//4zhw4cX6DjXrl0DALi6uhqUu7q6KttEBIGBgRg5ciRatGiBixcvGtX23LlzMX369Gzlf/75p9FJmrFCQkJM2l5pwD6VDexT7jLSzHA9rgUAFc7G7caFWxkmabeg+BmVDexT3h48eGCytsoKi3PnzkGlUqFSpUoGG3r06IF169YVqlEfHx9ERETg7t27+PnnnzFo0CDs2bMHkZGRSE5OhrOzs0H9hw8fKmtu7d27F927d1e2paWlQUTw888/K2XLli3DwIEDjYpl8eLFuHfvHiZPnlygPkyePBkTJ05UXiclJaFq1aro2rUrtFptgdrKTXp6OkJCQtClSxdYWpaPSxDsU9nAPuXv4ol07EMStBVV6N23qwkiLBh+RmUD+2ScrKtATxMLFxcX3Lp1K9uGatWq4cqVK4Vq1MrKSln2oXnz5jh06BAWLlyI6tWrw93dHbt37862j6OjIwCgRYsWBnf4LVq0CFeuXMEnn3yilGWNWGXNF0tISIC7u7uyPSEhAU2aNAEA7Ny5E2FhYcqIWZYWLVpg4MCBWLlyZY59UKvV2fYBAEtLS5OfREXRZkljn8oG9il3Vy+kAQCq1LYq0feIn1HZwD7l39bTJtdbY27cuJFjglEYer0eqampaNasGa5duwYLCwt4eXnlWFej0SjJGQA4OTkhKSnJoCyLt7c33NzcEBoaqiRUSUlJCA8Px6hRowBkJmizZs1S9omPj0dAQACyLo0SEeXkv0fk8A5CIiq4HL85MjIysHbtWrRu3brADU6ePBndu3dHtWrVcO/ePaxZswa7d+/G9u3b0blzZ/j5+aF3796YN28eateujfj4eGzevBl9+vRBixYtCnQslUqF8ePHY9asWahVqxa8vb3x0UcfwcPDQ1nDq1q1agb72NnZAQBq1KiBKlWqFLh/RPR0yHpETlU+g5CICsFi1KhRBnfb7dixA3PmzMGZM2fw5ZdfFrjB69ev4/XXX8fVq1fh4OCARo0aYfv27ejSpQsAYMuWLfjwww8xePBg3LhxA25ubujQoUO2ierGmjRpEu7fv4/hw4cjMTER7dq1w7Zt22BtbV2o9oiI0lIFCRez1sBigkVEBWexbt06LF++HADw6quvQkSg1WqxatUqdOjQocAN5nfXob29PRYtWoRFixYZ1V5QUFCe21UqFWbMmIEZM2YY1Z6XlxdExKi6RPR0uno+HXodYOdoBgcXruBORAVncenSJYSEhCA6Ohp6vR41atRAQEAA7O3tSzo2IqISkXV5sIqPBVQqVQlHQ0RlkYWtrW2Ozxy8efMmTp8+XahRLCKisowruBPRk8p17Ds0NBTPPPNMccZCRFQqXFLuIGSCRUSFk2uClZqaCnNz8+KMhYioxGWkCa5dyLqDkEs0EFHhWPz111/ZChMTE7Fs2TJ4enqWQEhERCXnamwGdBmAjb0KFdz4RyYRFY5FTpcBRQTm5uZYtmxZCYRERFRyshYYrVzbkhPciajQLH766SeDApVKBVtbWzRp0qTQa1MREZVVWRPcucAoET0JixdffLGkYyAiKjUuR/23RAMRUWHlOsk9KSkJGRkZxRkLEVGJ0mUI4mO4RAMRPblcE6y2bdvi7bffLs5YiIhKVMLFDGSkAda2KjhX5gR3Iiq8XBOsl156CVu2bCnOWIiISlTW/KvKtSxgZsYJ7kRUeLkmWB4eHrhy5UpxxkJEVKIuRWWtf8XLg0T0ZHJNsM6cOQOtVlucsRARlSjlETlMsIjoCZkdO3YsW+HRo0exfPlydO/evQRCIiIqfnqdID763zsIOcGdiJ6QRatWrfDCCy+gfv36AICTJ0/i999/R6VKlTBz5swSDo+IqHhcj9MhLUVgpVHBpSonuBPRk7EYMGAAfv31V2zcuBEAoNVqMXDgQMyZMwceHh4lHB4RUfFQJrjXtICZOSe4E9GTsVi5ciVEBDdu3AAAuLi48PEQRPTU4fwrIjIlCyDz8ThqtRp2dnZMrojoqXTpLBMsIjIds27dusHGxgbOzs7Ys2cPAODmzZvo1asXdu/eXbLREREVA71OcPlc5gT3anWYYBHRkzOLjo7Gq6++Cr1erxRWrFgRd+/exbJly0owNCKi4pHwTwbSHmZOcK9UjRPciejJmZ0+fRpz5szJtuGZZ55BeHh4CYRERFS8shYYrVKbE9yJyDTM1Gp1jvOuKleujGvXrpVASERExStr/hUvDxKRqeS6kvuVK1dgZ2dXnLEQEZWIrASrKhMsIjKRHBOs+/fvY8WKFfD39y/ueIiIipUuQxAfzQSLiEzLrEePHti6dSsAIDIyEt988w2aN2+OGzdu4KOPPirh8IiIita12AykpwHWdipUrMIJ7kRkGhbnz5/H66+/DgB4++23AQA1atTAli1b0KhRo5KMjYioyCmXB30suQ4gEZmMRVRUFI4dO4bz589Dr9ejRo0aaN68Ob9oiOipEHeGlweJyPQsAKBp06Zo2rRpScdCRFTslDsI6zLBIiLTsfjyyy+xZcsWXLx4EQDg5eWF5557DkOHDoW1tXXJRkdEVITSUwVXL2SugcURLCIyJbO33noLkZGRcHFxgYuLCyIjI/HWW2+hSZMmuHz5cknHR0RUZOJj0qHLAGwdVajgmuuqNUREBWb2008/4cqVK9izZw/27NmDK1euYN26dYiLi8OYMWNKOj4ioiJz6ex/zx/kvFMiMiWLl156KVth3759cfToUSxevLgEQiIiKh5cYJSIikquY+Jubm6wt7cvzliIiIrVpSgmWERUNMwePHiQrTA5ORkrVqzAkCFDSiAkIqKil/pQj2uxnOBOREXDok6dOhg0aBBq1qwJAIiOjsaqVavg5OSERo0aYcOGDQY7/N///V9JxElEZFJXojMgesChohkcKnIFdyIyLYvLly9j9uzZ2TZcvnwZ/fv3h4goZSqVCjqdrjjjIyIqEpx/RURFyWLXrl0lHQMRUbFjgkVERcnC39+/pGMgIip2yiNyfJhgEZHp5bmy3s8//1xccRARFZv7SXrcuJQ53aFaPSZYRGR6Znq9Plvh7du38fLLL+Pll18ugZCIiIpW3OnM0SuXKuawdeAK7kRkemZt2rRBVFSUUrBp0ybUr18fmzdvxoIFC0ouMiKiIvLPvwmWZ32OXhFR0bC4fPkymjZtimnTpuHEiRNYs2YN2rRpg+DgYGXpBiKi8uSfU2kAAM/6ViUcCRGVVxanTp1CQEAAPvjgAwDAhx9+iBkzZvC5XERULun1olwi5AgWERUVs0mTJuHgwYNo1KgRNBoNvvvuO2zdurWk4yIiKhI3L+vw4J7A0grwqGFR0uEQUTlltnLlSsydOxdHjhzBsWPH4OXlhZ49e2Lo0KG4d+9eScdHRGRSF09ljl5VqWMJcwuO1BNR0TA7cuQI3nvvPZiZmaFWrVrYt28fPvnkE6xZswYNGzYs6fiIiEwq7t/5V168PEhERcisfv36BgUqlQrvvPMOjhw5AldX1xIKi4ioaFxU5l9xgjsRFZ1cF4CpW7cuwsLCijMWIqIilfpQj6sxGQAATy4wSkRFKNcEKzY2Fj/88ENxxkJEVKQuR2VArwMcXMzgWMm8pMMhonLMzMbGBnv27Mm24e+//8bgwYML3ODcuXPRsmVL2Nvbo1KlSujdu7fBQqZFQUQwdepUuLu7Q6PRoHPnzoiOjs6xbmpqKpo0aQKVSoWIiIgijYuISpeLyvpXHL0ioqJllpKSAp1OZ7IG9+zZgzFjxuDAgQMICQlBeno6unbtivv37xe6zaCgIAQGBua6fd68eVi0aBGWLl2K8PBw2NraIiAgACkpKdnqTpo0CR4eHoWOhYjKrqz1r7zqcf4VERUtkz+Ea9u2bQgMDET9+vXRuHFjBAcHIy4uDkeOHFHqJCYmYujQoXBxcYFWq8Wzzz6LyMjIQh1PRLBgwQJMmTIFvXr1QqNGjbBq1SrEx8dj06ZNBnW3bt2KP//8E5999tmTdJGIyiARwcWTmQlWNY5gEVERK/JV9u7evQsAcHJyUsr69u0LjUaDrVu3wsHBAcuWLUOnTp1w7tw5g3rGiI2NxbVr19C5c2elzMHBAb6+vggLC8Mrr7wCAEhISMCwYcOwadMm2NjY5NtuamoqUlNTlddJSUkAgPT0dKSnpxcoxtxktWOq9koD9qlseBr7lHhdh6RbepiZAW7VS3/fn8bPqCxinwrW5tOkSBMsvV6P8ePHo23btmjQoAEAYN++fTh48CCuX78OtVoNAPjss8+wadMm/Pzzzxg+fHiBjnHt2jUAyLakhKurq7JNRBAYGIiRI0eiRYsWuHjxYr7tzp07F9OnT89W/ueffxqVoBVESEiISdsrDdinsuFp6tP1KCcAtWDjch87doYXb1BP4Gn6jMoy9ilvDx48MFlbZYUFAERHR8PR0dFgQ2xs7BM3PmbMGJw8eRL79u1TyiIjI5GcnAxnZ2eDug8fPkRMTAwAYO/evejevbuyLS0tDSKCn3/+WSlbtmwZBg4caFQcixcvxr179zB58mSjY588eTImTpyovE5KSkLVqlXRtWtXaLVao9vJS3p6OkJCQtClSxdYWpaPSxbsU9nwNPbp94v3AaSgYWsnPPfcc8UfYAE9jZ9RWcQ+GSfrKtDTxAIARo8enW2DiDzRA5/Hjh2LP/74A3/99ReqVKmilCcnJ8Pd3R27d+/Otk9WkteiRQuDO/wWLVqEK1eu4JNPPlHKskas3NzcAGReAnR3d1e2JyQkoEmTJgCAnTt3IiwsTBkxy9KiRQsMHDgQK1euzBaLWq3OVh8ALC0tTX4SFUWbJY19Khuepj5dOpt5M493A+sy1een6TMqy9in/Nt62lisWLHCpA2KCN58801s3LgRu3fvhre3t8H2Zs2a4dq1a7CwsICXl1eObWg0GtSsWVN57eTkhKSkJIOyLN7e3nBzc0NoaKiSUCUlJSE8PByjRo0CkJmgzZo1S9knPj4eAQEBWLduHXx9fZ+wx0RU2mWkC65EZa3g/vR90RNR8bMYNGiQSRscM2YM1qxZg19//RX29vbKPCgHBwdljSo/Pz/07t0b8+bNQ+3atREfH4/NmzejT58+aNGiRYGOp1KpMH78eMyaNQu1atWCt7c3PvroI3h4eKB3794AgGrVqhnsY2dnBwCoUaOGwegaEZVPl6PSkZ4G2Dqo4FKVC4wSUdEz+ST3//3vfwCAjh07GpSvWLECgYGBUKlU2LJlCz788EMMHjwYN27cgJubGzp06FDoZx9OmjQJ9+/fx/Dhw5GYmIh27dph27ZtsLa2ftLuEFE5cOF45uiVdyOrJ5r6QERkLJMnWCKSbx17e3ssWrQIixYtMqrNoKCgPLerVCrMmDEDM2bMMKo9Ly8vo+IkovLhQmTmCu7VG3GBUSIqHiZfaJSIqDTR6wWxx/9NsBpz/hURFQ8mWERUrl2LzcCDewIraxWq1GaCRUTFgwkWEZVrFyL/ff5gA0uYW3D+FREVDyZYRFSuKfOvGnP+FREVHyZYRFRuiQgucP4VEZUAJlhEVG7dvqrD3Rt6mFsAnvU4gkVExYcJFhGVWzH/zr+q4mMJK2vOvyKi4sMEi4jKraz5VzU4/4qIihkTLCIqt/6b4M75V0RUvJhgEVG5dO+2Djcu6aBSAd4NOYJFRMWLCRYRlUtZzx90q24BGy2/6oioePFbh4jKpZgIPn+QiEoOEywiKpe4/hURlSQmWERU7qTc1yP+fAYAruBORCWDCRYRlTuxx9MhesDZwxyOLuYlHQ4RPYWYYBFRuXPucCoAoGYzjl4RUclggkVE5U7U4cz5Vz4tmWARUclggkVE5cq923pcjcmcf1WrubqEoyGipxUTLCIqV6KPZK5/Vbm2Bewc+RVHRCWD3z5EVK5EH85MsHxacPSKiEoOEyyi/2fvzsOiqv4/gL9nhmHYQVA2RUXcNzQXcktNFM1MMnfLpbS+LpWSmVbu/aKsXCpLKxWtTLNMK1ek1EzSXHAXFcEVcGNfhlnO74+RyREQGAZm4f16nnl07j33zOfMnbl85txzzyWbIQRw4ahu/FVjjr8iIjNigkVENiP3riOy7grI7TmDOxGZFxMsIrIZaVfcAACBwfaQKyRmjoaIqjMmWERkM+4luQMAmnTg+CsiMi8mWERkE9QqgfRruh4szn9FRObGBIuIbMLVs2poVTI4e0jgF2Rn7nCIqJpjgkVENqFw/qtGj8khlXL8FRGZFxMsIrIJhfNfNWovN3MkRERMsIjIBuRmanEt/v7tcZhgEZEFYIJFRFbv0vECCC3g5JkHj1oyc4dDRMQEi4is37l/lACAGvUzzBwJEZEOEywismparcCZg7oEy6tBunmDISK6jwkWEVm1q2dVyLqrhYOzBB51M80dDhERACZYRGTlTh/Q9V41CZFDKhNmjoaISIcJFhFZtVN/5QMAWnTh7O1EZDmYYBGR1bp1VY1bVzSQ2QFNOnJ6BiKyHEywiMhqFZ4eDGprD0cXHs6IyHLwiEREVuv0/dODrboqzBwJEZEhJlhEZJWy0jRIOq27PU6Lrg5mjoaIyBATLCKySmf/VkIIoE5jO9Tw4eztRGRZmGARkVUqHH/Vsht7r4jI8jDBIiKro8zTIv6wLsFq1Y3jr4jI8jDBIiKrc+HfAqgKAE8/GfyC7MwdDhFREUywiMjq6E8PdlVAIpGYORoioqKYYBGRVVEpBU7uvz89wxMcf0VElokJFhFZlTMHlcjPFvDwlqJBMGdvJyLLxASLiKzK0V15AIB2fRwhlfL0IBFZJiZYRGQ1stO1OBurG3/Vrg9PDxKR5WKCRURWI+6PfGg1QO3GdvBrwNODRGS5TJ5g7d+/HwMGDIC/vz8kEgm2bNli6pcoYvny5ahfvz4cHBwQEhKCw4cPF1tOCIF+/fpVWVxEZFpH7p8ebN/H0cyREBE9mskTrJycHAQHB2P58uUmqS8qKgo9evQocf3GjRsRERGBuXPn4tixYwgODkZYWBhu3bpVpOzSpUt5STeRlbp9XY0rZ1SQSIG2oTw9SESWzeQJVr9+/fDee+/h2WefLXa9UqnE9OnTUbt2bTg7OyMkJAR79+41+vUWL16MCRMmYNy4cWjevDlWrFgBJycnrF692qBcXFwcPvnkkyLLicg6FA5ub9LeHu41ee9BIrJsVT4F8pQpU3D27Fls2LAB/v7++OWXX9C3b1+cOnUKjRo1KlddBQUFOHr0KGbNmqVfJpVKERoaitjYWP2y3NxcjBw5EsuXL4evr2+Z6lYqlVAqlfrnmZmZAACVSgWVSlWuOEtSWI+p6rMEbJN1sLY2CSH0pwfbhNoXG7e1tak0ttYegG2yFpXRJlt6f8qqShOsq1evYs2aNbh69Sr8/f0BANOnT8fOnTuxZs0avP/+++Wq786dO9BoNPDx8TFY7uPjg/Pnz+ufT5s2DZ07d8bAgQPLXHdkZCTmz59fZPnu3bvh5ORUrjhLEx0dbdL6LAHbZB2spU0ZN1xw92YLSOUa3Mj5EynbtSWWtZY2lZWttQdgm6yFKduUm5trsrqsRZUmWKdOnYJGo0Hjxo0NliuVSnh5eQHQJWHNmzfXr1Or1VCpVHBxcdEve/vtt/H222+X6TV//fVX/PHHHzh+/Hi5Yp01axYiIiL0zzMzMxEQEIA+ffrAzc2tXHWVRKVSITo6Gr1794ZcbhtXRLFN1sHa2vTLkmwASrTp4YgB4X2LLWNtbSqNrbUHYJusRWW0qfAsUHVSpQlWdnY2ZDIZjh49CpnMcAxFYQLl7++PuLg4/fLNmzfj559/xvfff69f5unpCQCoWbMmZDIZUlNTDepKTU3Vnwr8448/kJCQAA8PD4Myzz33HLp161bi+C+FQgGFQlFkuVwuN/mXqDLqNDe2yTpYQ5sKlAIn9hYAADr0cy41XmtoU3nYWnsAtslamLJNtvbelEWVJlht27aFRqPBrVu30K1bt+IDsrNDw4YN9c+9vb3h6OhosKyQvb092rVrh5iYGISHhwMAtFotYmJiMGXKFADAzJkzMX78eIPtWrVqhSVLlmDAgAEmahkRVZbje/KQmylQw0eKxu3szR0OEVGZmDzBys7OxqVLl/TPExMTERcXB09PTzRu3BijRo3C6NGj8cknn6Bt27a4ffs2YmJi0Lp1a/Tv37/crxcREYExY8agffv26NixI5YuXYqcnByMGzcOAODr61vswPa6desiMDDQ+IYSUaUTQuCvn3VjN7o86wSpjNOsEJF1MHmCdeTIEfTs2VP/vHAc05gxYxAVFYU1a9bgvffewxtvvIEbN26gZs2aePzxx/H0008b9XrDhg3D7du3MWfOHKSkpKBNmzbYuXNnkYHvRGR9Ek+qcOOCGnJ74PEBpr24hIioMpk8werRoweEECWul8vlmD9/frFX6BVn7NixGDt27CPLTJkyRX9KsCweFR8RWY7C3qvH+jjC2Z139iIi68EjFhFZpPRbGpzclw8A6PYce6+IyLowwSIii3RwSy60GiCojRy1G1W/K5CIyLoxwSIii6NSChz8VXd6sNtgZzNHQ0RUfkywiMjiHP8jHznpAh7eUrTsWnQ+OiIiS8cEi4gsihACf23KAaCbmkFmx6kZiMj6MMEiIouScLwA1zk1AxFZOSZYRGQxhBDYsSobANDxKUe4ePAQRUTWiUcvIrIYF44U4PIJFezsgdAxLqVvQERkoZhgEZFFEEJgx9e63qvOA53gUUtWyhZERJaLCRYRWYSzsUpcOauCXAH0ep5TMxCRdWOCRURmJ4TAzm90vVddn3OGmxd7r4jIujHBIiKzO/2XEtcvqKFwlODJkey9IiLrxwSLiMxKq/3vysEnhjjxykEisgk8khGRWR3fk4/kBDUcXCToMZy9V0RkG5hgEZHZ5GVr8evyLADAkyOc4eTGQxIR2QYezYjIbHZ8k43Mu1rUqiNDzxHsvSIi28EEi4jM4lq8Cgc25wIAnnvDDXb2vOcgEdkOJlhEVOW0GoGfPs6E0AKPhTqgSQeFuUMiIjIpJlhEVOUObs3D1XMqODhLMPBVV3OHQ0RkckywiKhKZd7VYNtXuoHt/V924aSiRGSTmGARUZURQuDnxZnIzxYIaGqHzuFO5g6JiKhSMMEioipzcEseTu5TQmYHDHnTHVIZB7YTkW1igkVEVeLGRRW2fJYJAHh6oisCmsjNHBERUeVhgkVElS4/V4u1c9KhLgCad1ag+1CeGiQi28YEi4gqlRC6KRluX9PAw1uKke+4QyLhqUEism1MsIioUh3enoeju/MhlQEvzPWAszsPO0Rk+3ikI6JKc+mYEps+1o276vuSCxoE25s5IiKiqsEEi4gqxc1LKqyalQ6NCmj1hAK9nue9Bomo+mCCRUQml5aiwVfT05CfI9AgWI4X5npAKuW4KyKqPphgEZFJ5WRoseKNe8i4o4VvoB1eiqwBuYLJFRFVL0ywiMhk8nO0+OatNNy6orti8JVPasDJjYcZIqp+7MwdABHZhqx7GqycnoYbF9RwdJHg5Y9rwMOb9xkkouqJCRYRVdjdm2qsiEjDnesauNTQ9Vz5NeBM7URUfTHBIqIKuZmgwsqINGTe1cLTT4b/La6BWgE8tBBR9cajIBEZ7fwhJdbNTUdetoBfAzu8srgG3GvytCARERMsIio3jVpg1+psRK/LAQDUbyXHhA85oJ2IqBATLCIql4w7Gnw7Lx0JcSoAQJdwRwx81Y1TMRARPYAJFhGV2ekD+dj4YSay07RQOEow9C03PBbqaO6wiIgsDhMsIipVWqoGvyzLxKn9SgCAf5Adxiz0gHddHkKIiIrDoyMRlUijFvjr51zs/CYbyjwBqQzoMcwZYS+5wJ6nBImISsQEi4iK0GoFTu5VYufqbKQmqQHoBrIPme4G/yDOb0VEVBomWESkJ4TA6b+U2LkqGzcTdImVk6sET090RcjTjrxhMxFRGTHBIiIU5Asci87DXz/n4uYlXWLl4CxB92HO6D7UCY4unH6BiKg8mGARVWO3r2tw+Pc8HN6Wh7xsAQCwd5TgicFO6DHCGc6c14qIyChMsIiqmfTbGhyNzsPRX1pgb3K6frmXvwxdwp3Qsb8jnN2ZWBERVQQTLCIbJ4RA8mU1zh8qwJm/85F4UgUhAMAFEinQtKM9uj7njKYh9hxjRURkIkywiGyMEAL3kjVIPKXCpeMFOH9IiYzbWoMy9VvZwc77EkZMagtPH4WZIiUisl1MsIisXE6GFjcuqnDjghpXzhYg8ZQKmXcNEyq5Amj4mAJNO9qj1RMOcPHUYvv2VLh68lQgEVFlqLQEa/ny5fjoo4+QkpKC4OBgfPbZZ+jYsWOlvJYQAnPnzsXXX3+N9PR0dOnSBV9++SUaNWqkL3Pv3j28+uqr+O233yCVSvHcc89h2bJlcHFxqZSYiExJCIHsdC1uXdXg9lU1Uq+oceuqBjcvqZB+S1ukvFQGBDSRI7CVHE1CFGgQbG8wMahKVXQbIiIynUpJsDZu3IiIiAisWLECISEhWLp0KcLCwhAfHw9vb+9y1zdv3jwkJSUhKiqq2PWLFi3Cp59+irVr1yIwMBCzZ89GWFgYzp49CwcHBwDAqFGjkJycjOjoaKhUKowbNw4vv/wy1q9fX5GmElWYEAL5OQJZ97TIuK1Bxh3dv+m3tbiXrNE9UjQoyBMl1lGztgy1G9mhThM5AlvZI6CZnDOtExGZUaUkWIsXL8aECRMwbtw4AMCKFSuwbds2rF69GjNnzkR6ejqmT5+OrVu3QqlUon379liyZAmCg4PL/VpCCCxduhTvvvsuBg4cCABYt24dfHx8sGXLFgwfPhznzp3Dzp078e+//6J9+/YAgM8++wxPPfUUPv74Y/j7+5uu8VTtCCGgLgCUeQIFeVoo8wSUubqkKS9bi/wcgfxsgdwsLfKytMjNEsjJ1CInQ4vsNC2y07XQqEp/HYkEqOErg3ddGbzr2sG7nh18A+1Qu6EdHJx5qo+IyJKYPMEqKCjA0aNHMWvWLP0yqVSK0NBQxMbGAgCGDBkCR0dH7NixA+7u7li5ciV69eqFCxcuwNPTs1yvl5iYiJSUFISGhuqXubu7IyQkBLGxsRg+fDhiY2Ph4eGhT64AIDQ0FFKpFIcOHcKzzz5bwVYbJy1Fg7x0Be7e1MDOzvjeBlFyx8b9AuUsX1wZYbhcPFSg8KlapUb2LUckJ6ghkz28ja4ecb8+IcT9f3XrtdqH1/9XRnv/jJbQ6h5aIXT/F/efawGhFRAC0GruP9cIaLX//V+jKVwnoFVD91wtoFEDGs39f9UCGpXuX3WBblmBUotbKc1weVsGNCpAVSCgUgqo8oECpYAqX5TpPS2Ng7ME7rWkcPOSwb2WFB61ZKjhK4OnnwxefjLU8JHBzp69UkRE1sDkCdadO3eg0Wjg4+NjsNzHxwfnz5/HgQMHcPjwYdy6dQsKhe7qpY8//hhbtmzBTz/9hJdffrlcr5eSkqKv/+HXK1yXkpJS5NSknZ0dPD099WUeplQqoVQq9c8zMzMBACqVCipVGbobyuCzSRnITmuDQ1+nm6Q+y9EaR9ZmmDsIE3NDOtSllpIrdBN12jtI4OBs+HB0lcLJVQInVwkc3aRwcpPAtYYUzh4SuHhIIX/kKT0BATVM9NHTf4ZN9Vm2BLbWJltrD8A2WYvKaJMtvT9lVeVXEZ44cQLZ2dnw8vIyWJ6Xl4eEhAQAwF9//YV+/frp1xUUFEAIgZ9++km/bOXKlRg1alSlxRkZGYn58+cXWb579244OTmZ5DXU2mDI5EbcOLdMnRgPdamUso2k2CfF1yEpUs6wvOTh5Q88l0iEYV0SYVBOAgAS8cD/H9xG6OrW/wtIIADp/TL3y0okgEQqdOXur5NIxf1/ddtLZfefP/CvVHa/nFRAKtPqnt//V2qn1T0e+L9MrjX4v0yu0dX/CGoAmQAy1QDu3X+YUXR0tHkDqAS21iZbaw/ANlkLU7YpNzfXZHVZC5MnWDVr1oRMJkNqaqrB8tTUVPj6+iI7Oxt+fn7Yu3dvkW09PDwAAO3bt0dcXJx++aeffoobN27gww8/1C8r7LHy9fXV1+/n52fwem3atNGXuXXrlsFrqdVq3Lt3T7/9w2bNmoWIiAj988zMTAQEBKBPnz5wc3N79JtQRr17qxAdHY3evXtDbkyiZYFUKrbJGrBNls/W2gOwTdaiMtpUeBaoOjF5gmVvb4927dohJiYG4eHhAACtVouYmBhMmTIFjz32GFJSUmBnZ4f69esXW4ejoyMaNmyof+7p6YnMzEyDZYUCAwPh6+uLmJgYfUKVmZmJQ4cOYeLEiQCATp06IT09HUePHkW7du0AAH/88Qe0Wi1CQkKKjUGhUOhPYT5ILpeb/EtUGXWaG9tkHdgmy2dr7QHYJmthyjbZ2ntTFpVyijAiIgJjxoxB+/bt0bFjRyxduhQ5OTkYN24cvL290alTJ4SHh2PRokVo3Lgxbt68iW3btuHZZ581GIheFhKJBFOnTsV7772HRo0a6adp8Pf31yd4zZo1Q9++fTFhwgSsWLECKpUKU6ZMwfDhw3kFIREREZlcpSRYw4YNw+3btzFnzhykpKSgTZs22Llzp/603vbt2/HOO+9g3LhxuH37Nnx9ffHEE08UGaheVjNmzEBOTg5efvllpKeno2vXrti5c6d+DiwA+P777zFlyhT06tVLP9Hop59+apL2EhERET2o0ga5T5kyBVOmTCl2naurKz799NMyJzjz5s175HqJRIIFCxZgwYIFJZbx9PTkpKJERERUJTg7IREREZGJMcEiIiIiMjEmWEREREQmxgSLiIiIyMSYYBERERGZGBMsIiIiIhNjgkVERERkYkywiIiIiEyMCRYRERGRiTHBIiIiIjIxJlhEREREJsYEi4iIiMjEKu1mz7ZGCAEAyMzMNFmdKpUKubm5yMzMhFwuN1m95sQ2WQe2yfLZWnsAtslaVEabCv92Fv4trQ6YYJVRVlYWACAgIMDMkRAREVmnrKwsuLu7mzuMKiER1SmdrACtVoubN2/C1dUVEonEJHVmZmYiICAA165dg5ubm0nqNDe2yTqwTZbP1toDsE3WojLaJIRAVlYW/P39IZVWj9FJ7MEqI6lUijp16lRK3W5ubjbzxSzENlkHtsny2Vp7ALbJWpi6TdWl56pQ9UgjiYiIiKoQEywiIiIiE2OCZUYKhQJz586FQqEwdygmwzZZB7bJ8tlaewC2yVrYYpvMgYPciYiIiEyMPVhEREREJsYEi4iIiMjEmGARERERmRgTLCIiIiITY4JVyZYvX4769evDwcEBISEhOHz48CPLb9q0CU2bNoWDgwNatWqF7du3V1GkpYuMjESHDh3g6uoKb29vhIeHIz4+/pHbREVFQSKRGDwcHByqKOLSzZs3r0h8TZs2feQ2lryPAKB+/fpF2iSRSDB58uRiy1viPtq/fz8GDBgAf39/SCQSbNmyxWC9EAJz5syBn58fHB0dERoaiosXL5Zab3m/j6b0qDapVCq89dZbaNWqFZydneHv74/Ro0fj5s2bj6zTmM+vqZS2j8aOHVsktr59+5Zar6XuIwDFfq8kEgk++uijEus05z4Cynbczs/Px+TJk+Hl5QUXFxc899xzSE1NfWS9xn4HqxMmWJVo48aNiIiIwNy5c3Hs2DEEBwcjLCwMt27dKrb8wYMHMWLECLz00ks4fvw4wsPDER4ejtOnT1dx5MXbt28fJk+ejH/++QfR0dFQqVTo06cPcnJyHrmdm5sbkpOT9Y8rV65UUcRl06JFC4P4Dhw4UGJZS99HAPDvv/8atCc6OhoAMGTIkBK3sbR9lJOTg+DgYCxfvrzY9YsWLcKnn36KFStW4NChQ3B2dkZYWBjy8/NLrLO830dTe1SbcnNzcezYMcyePRvHjh3D5s2bER8fj2eeeabUesvz+TWl0vYRAPTt29cgth9++OGRdVryPgJg0Jbk5GSsXr0aEokEzz333CPrNdc+Asp23J42bRp+++03bNq0Cfv27cPNmzcxaNCgR9ZrzHew2hFUaTp27CgmT56sf67RaIS/v7+IjIwstvzQoUNF//79DZaFhISIV155pVLjNNatW7cEALFv374Sy6xZs0a4u7tXXVDlNHfuXBEcHFzm8ta2j4QQ4vXXXxdBQUFCq9UWu97S9xEA8csvv+ifa7Va4evrKz766CP9svT0dKFQKMQPP/xQYj3l/T5WpofbVJzDhw8LAOLKlSsllinv57eyFNeeMWPGiIEDB5arHmvbRwMHDhRPPvnkI8tYyj4q9PBxOz09XcjlcrFp0yZ9mXPnzgkAIjY2ttg6jP0OVjfswaokBQUFOHr0KEJDQ/XLpFIpQkNDERsbW+w2sbGxBuUBICwsrMTy5paRkQEA8PT0fGS57Oxs1KtXDwEBARg4cCDOnDlTFeGV2cWLF+Hv748GDRpg1KhRuHr1aollrW0fFRQU4LvvvsOLL774yJuUW/o+elBiYiJSUlIM9oO7uztCQkJK3A/GfB/NLSMjAxKJBB4eHo8sV57Pb1Xbu3cvvL290aRJE0ycOBF3794tsay17aPU1FRs27YNL730UqllLWkfPXzcPnr0KFQqlcH73rRpU9StW7fE992Y72B1xASrkty5cwcajQY+Pj4Gy318fJCSklLsNikpKeUqb05arRZTp05Fly5d0LJlyxLLNWnSBKtXr8bWrVvx3XffQavVonPnzrh+/XoVRluykJAQREVFYefOnfjyyy+RmJiIbt26ISsrq9jy1rSPAGDLli1IT0/H2LFjSyxj6fvoYYXvdXn2gzHfR3PKz8/HW2+9hREjRjzyZrvl/fxWpb59+2LdunWIiYnBhx9+iH379qFfv37QaDTFlre2fbR27Vq4urqWeirNkvZRccftlJQU2NvbF0nkS/tbVVimrNtUR3bmDoCs0+TJk3H69OlSxxJ06tQJnTp10j/v3LkzmjVrhpUrV2LhwoWVHWap+vXrp/9/69atERISgnr16uHHH38s0y9TS7dq1Sr069cP/v7+JZax9H1U3ahUKgwdOhRCCHz55ZePLGvJn9/hw4fr/9+qVSu0bt0aQUFB2Lt3L3r16mXGyExj9erVGDVqVKkXhFjSPirrcZtMgz1YlaRmzZqQyWRFrsRITU2Fr69vsdv4+vqWq7y5TJkyBb///jv+/PNP1KlTp1zbyuVytG3bFpcuXaqk6CrGw8MDjRs3LjE+a9lHAHDlyhXs2bMH48ePL9d2lr6PCt/r8uwHY76P5lCYXF25cgXR0dGP7L0qTmmfX3Nq0KABatasWWJs1rKPAOCvv/5CfHx8ub9bgPn2UUnHbV9fXxQUFCA9Pd2gfGl/qwrLlHWb6ogJViWxt7dHu3btEBMTo1+m1WoRExNj0FvwoE6dOhmUB4Do6OgSy1c1IQSmTJmCX375BX/88QcCAwPLXYdGo8GpU6fg5+dXCRFWXHZ2NhISEkqMz9L30YPWrFkDb29v9O/fv1zbWfo+CgwMhK+vr8F+yMzMxKFDh0rcD8Z8H6taYXJ18eJF7NmzB15eXuWuo7TPrzldv34dd+/eLTE2a9hHhVatWoV27dohODi43NtW9T4q7bjdrl07yOVyg/c9Pj4eV69eLfF9N+Y7WC2ZeZC9TduwYYNQKBQiKipKnD17Vrz88svCw8NDpKSkCCGEeOGFF8TMmTP15f/++29hZ2cnPv74Y3Hu3Dkxd+5cIZfLxalTp8zVBAMTJ04U7u7uYu/evSI5OVn/yM3N1Zd5uE3z588Xu3btEgkJCeLo0aNi+PDhwsHBQZw5c8YcTSjijTfeEHv37hWJiYni77//FqGhoaJmzZri1q1bQgjr20eFNBqNqFu3rnjrrbeKrLOGfZSVlSWOHz8ujh8/LgCIxYsXi+PHj+uvqPvggw+Eh4eH2Lp1qzh58qQYOHCgCAwMFHl5efo6nnzySfHZZ5/pn5f2fTRnmwoKCsQzzzwj6tSpI+Li4gy+X0qlssQ2lfb5NVd7srKyxPTp00VsbKxITEwUe/bsEY899pho1KiRyM/PL7E9lryPCmVkZAgnJyfx5ZdfFluHJe0jIcp23P7f//4n6tatK/744w9x5MgR0alTJ9GpUyeDepo0aSI2b96sf16W72B1xwSrkn322Weibt26wt7eXnTs2FH8888/+nXdu3cXY8aMMSj/448/isaNGwt7e3vRokULsW3btiqOuGQAin2sWbNGX+bhNk2dOlXffh8fH/HUU0+JY8eOVX3wJRg2bJjw8/MT9vb2onbt2mLYsGHi0qVL+vXWto8K7dq1SwAQ8fHxRdZZwz76888/i/2sFcat1WrF7NmzhY+Pj1AoFKJXr15F2lqvXj0xd+5cg2WP+j5Wtke1KTExscTv159//llim0r7/JqrPbm5uaJPnz6iVq1aQi6Xi3r16okJEyYUSZSsaR8VWrlypXB0dBTp6enF1mFJ+0iIsh238/LyxKRJk0SNGjWEk5OTePbZZ0VycnKReh7cpizfwepOIoQQldM3RkRERFQ9cQwWERERkYkxwSIiIiIyMSZYRERERCbGBIuIiIjIxJhgEREREZkYEywiIiIiE2OCRURERGRiTLCIiIiITIwJFhFVmqioKEgkkhIf//zzj7lDJCKqFHbmDoCIbN+CBQuKvTl4w4YNzRANEVHlY4JFRJWuX79+aN++vVljyMnJgbOzs1ljIKLqg6cIiciskpKSIJFI8PHHH+Orr75CUFAQFAoFOnTogH///bdI+fPnz2Pw4MHw9PSEg4MD2rdvj19//dWgTOGpyX379mHSpEnw9vZGnTp19OuXL1+OBg0awNHRER07dsRff/2FHj16oEePHgCA7OxsODs74/XXXy/y+tevX4dMJkNkZKRp3wgisinswSKiSpeRkYE7d+4YLJNIJPDy8tI/X79+PbKysvDKK69AIpFg0aJFGDRoEC5fvgy5XA4AOHPmDLp06YLatWtj5syZcHZ2xo8//ojw8HD8/PPPePbZZw1eY9KkSahVqxbmzJmDnJwcAMCXX36JKVOmoFu3bpg2bRqSkpIQHh6OGjVq6JMwFxcXPPvss9i4cSMWL14MmUymr/OHH36AEAKjRo2qlPeKiGyEICKqJGvWrBEAin0oFAohhBCJiYkCgPDy8hL37t3Tb7t161YBQPz222/6Zb169RKtWrUS+fn5+mVarVZ07txZNGrUqMjrdu3aVajVav1ypVIpvLy8RIcOHYRKpdIvj4qKEgBE9+7d9ct27dolAIgdO3YYtKl169YG5YiIisNThERU6ZYvX47o6GiDx44dOwzKDBs2DDVq1NA/79atGwDg8uXLAIB79+7hjz/+wNChQ5GVlYU7d+7gzp07uHv3LsLCwnDx4kXcuHHDoM4JEyYY9D4dOXIEd+/exYQJE2Bn918H/qhRowxeGwBCQ0Ph7++P77//Xr/s9OnTOHnyJJ5//vkKviNEZOt4ipCIKl3Hjh1LHeRet25dg+eFCU9aWhoA4NKlSxBCYPbs2Zg9e3axddy6dQu1a9fWP3/4ysUrV64AKHr1op2dHerXr2+wTCqVYtSoUfjyyy+Rm5sLJycnfP/993BwcMCQIUMe2RYiIiZYRGQRHuxpepAQAgCg1WoBANOnT0dYWFixZR9OnBwdHSsU0+jRo/HRRx9hy5YtGDFiBNavX4+nn34a7u7uFaqXiGwfEywisgoNGjQAAMjlcoSGhhpVR7169QDoesN69uypX65Wq5GUlITWrVsblG/ZsiXatm2L77//HnXq1MHVq1fx2WefGdkCIqpOOAaLiKyCt7c3evTogZUrVyI5ObnI+tu3b5daR/v27eHl5YWvv/4aarVav/z777/Xn4p82AsvvIDdu3dj6dKl8PLyQr9+/YxvBBFVG+zBIqJKt2PHDpw/f77I8s6dO0MqLfvvvOXLl6Nr165o1aoVJkyYgAYNGiA1NRWxsbG4fv06Tpw48cjt7e3tMW/ePLz66qt48sknMXToUCQlJSEqKgpBQUGQSCRFthk5ciRmzJiBX375BRMnTtRPGUFE9ChMsIio0s2ZM6fY5WvWrNFP7lkWzZs3x5EjRzB//nxERUXh7t278Pb2Rtu2bUt8jYdNmTIFQgh88sknmD59OoKDg/Hrr7/itddeg4ODQ5HyPj4+6NOnD7Zv344XXnihzLESUfUmEYUjSImIqimtVotatWph0KBB+Prrr4usf/bZZ3Hq1ClcunTJDNERkTXiGCwiqlby8/Px8O/KdevW4d69e8X2piUnJ2Pbtm3svSKicmEPFhFVK3v37sW0adMwZMgQeHl54dixY1i1ahWaNWuGo0ePwt7eHgCQmJiIv//+G9988w3+/fdfJCQkwNfX18zRE5G14BgsIqpW6tevj4CAAHz66ae4d+8ePD09MXr0aHzwwQf65AoA9u3bh3HjxqFu3bpYu3YtkysiKhf2YBERERGZGMdgEREREZkYEywiIiIiE2OCRURERGRiTLCIiIiITIwJFhEREZGJMcEiIiIiMjEmWEREREQmxgSLiIiIyMSYYBERERGZGBMsIiIiIhNjgkVERERkYkywiIiIiEyMCRYRERGRiTHBIiIiIjIxJlhEZLSxY8eifv365g7DJkgkEsybN8/cYVicixcvok+fPnB3d4dEIsGWLVuMrispKQkSiQQff/xxqWXnzZsHiURisKx+/foYO3ZsqdtGRUVBIpEgKSnJyEjJFjDBsjGFX+ySHv/884++rEQiwZQpU8pU72+//YYBAwbAx8cH9vb28PT0xBNPPIFPPvkEmZmZldUci/L+++8bfXAfO3YsXFxcSlxfnn1hjXr06FHiZ7Jp06bmDq/M1q9fj6VLl5rt9QsTBIlEgp9//rnI+sKk4M6dO2aIrnKMGTMGp06dwv/93//h22+/Rfv27c0dElGZ2Jk7AKocCxYsQGBgYJHlDRs2LFc9Wq0WL730EqKiotCqVStMmjQJAQEByMrKQmxsLN59911s374dMTExpgrdYr3//vsYPHgwwsPDzR2KVapTpw4iIyOLLHd3dzdDNMZZv349Tp8+jalTp5o7FCxYsACDBg0q0stiS/Ly8hAbG4t33nmnyn+AvPvuu5g5c2aVvibZFiZYNqpfv34m+aW3aNEiREVFYdq0afjkk08MDuavv/46kpOTsW7dugq/jqUSQiA/Px+Ojo7mDsUs8vPzYW9vD6m04p3d7u7ueP75500QFbVp0wZxcXH45ZdfMGjQIHOHU2lu374NAPDw8Kjy17azs4OdXeX9iazux5bqgKcIqUS5ubn48MMP0aJFC3z00UfF/lL28/PDW2+9ZbBMrVZj4cKFCAoKgkKhQP369fH2229DqVQalKtfvz6efvpp7N27F+3bt4ejoyNatWqFvXv3AgA2b96MVq1awcHBAe3atcPx48cNti887Xb58mWEhYXB2dkZ/v7+WLBgAYQQBmW1Wi2WLl2KFi1awMHBAT4+PnjllVeQlpZWbEy7du3Sx7Ry5UpIJBLk5ORg7dq1+lM0Y8eONThlU9zDWAUFBZgzZw7atWsHd3d3ODs7o1u3bvjzzz8Nyj3q1FtUVBQA4N69e5g+fTpatWoFFxcXuLm5oV+/fjhx4oRBXXv37oVEIsGGDRvw7rvvonbt2nByctKfAt6yZQtatmwJBwcHtGzZEr/88ovR7StOXl4emjZtiqZNmyIvL0+//N69e/Dz80Pnzp2h0WgAVM6+B4AdO3age/fucHV1hZubGzp06ID169cD0L3X27Ztw5UrV/Tv8YPjz5RKJebOnYuGDRtCoVAgICAAM2bMKPK5VyqVmDZtGmrVqgVXV1c888wzuH79erneq+HDh6Nx48bFtvdhJY0b6tGjB3r06KF/Xrj/f/zxR8yfPx+1a9eGq6srBg8ejIyMDCiVSkydOhXe3t5wcXHBuHHjirStPI4fP45+/frBzc0NLi4u6NWrl8EQhnnz5qFevXoAgDfffLPI+12c/Px8zJs3D40bN4aDgwP8/PwwaNAgJCQkFCn71Vdf6Y9RHTp0wL///muwvrgxWMU5c+YMnnzySTg6OqJOnTp47733oNVqi5Qr6dgCAOnp6Zg6dSoCAgKgUCjQsGFDfPjhhwb1PDh+rLTYyTKwB8tGZWRkFBmHIZFI4OXlVeY6Dhw4gPT0dEyfPh0ymazM240fPx5r167F4MGD8cYbb+DQoUOIjIzEuXPnivxRvnTpEkaOHIlXXnkFzz//PD7++GMMGDAAK1aswNtvv41JkyYBACIjIzF06FDEx8cb9KZoNBr07dsXjz/+OBYtWoSdO3di7ty5UKvVWLBggb7cK6+8gqioKIwbNw6vvfYaEhMT8fnnn+P48eP4+++/IZfL9WXj4+MxYsQIvPLKK5gwYQKaNGmCb7/9FuPHj0fHjh3x8ssvAwCCgoJQq1YtfPvttwZtUqlUmDZtGuzt7Yu8N2UdG5OZmYlvvvkGI0aMwIQJE5CVlYVVq1YhLCwMhw8fRps2bQAA77zzDsaPH2+w7XfffYddu3bB29sbAHD58mVs2bIFQ4YMQWBgIFJTU7Fy5Up0794dZ8+ehb+/v8H2CxcuhL29PaZPnw6lUgl7e3vs3r0bzz33HJo3b47IyEjcvXsX48aNQ506dcrUHkC3r4prv6OjI5ydneHo6Ii1a9eiS5cueOedd7B48WIAwOTJk5GRkYGoqCiDz6Gp931UVBRefPFFtGjRArNmzYKHhweOHz+OnTt3YuTIkXjnnXeQkZGB69evY8mSJQCgH1en1WrxzDPP4MCBA3j55ZfRrFkznDp1CkuWLMGFCxcMxu6NHz8e3333HUaOHInOnTvjjz/+QP/+/cv8PgKATCbDu+++i9GjR5u8FysyMhKOjo6YOXMmLl26hM8++wxyuRxSqRRpaWmYN28e/vnnH0RFRSEwMBBz5swp92ucOXMG3bp1g5ubG2bMmAG5XI6VK1eiR48e2LdvH0JCQjBo0CB4eHhg2rRpGDFiBJ566qlHjmPUaDR4+umnERMTg+HDh+P1119HVlYWoqOjcfr0aQQFBenLrl+/HllZWXjllVcgkUiwaNEiDBo0CJcvXzY4FpQmJSUFPXv2hFqtxsyZM+Hs7IyvvvqqxF6p4o4tubm56N69O27cuIFXXnkFdevWxcGDBzFr1iwkJycXGfNnqtipCgiyKWvWrBEAin0oFAqDsgDE5MmTS6xr2bJlAoDYsmWLwXK1Wi1u375t8NBqtUIIIeLi4gQAMX78eINtpk+fLgCIP/74Q7+sXr16AoA4ePCgftmuXbsEAOHo6CiuXLmiX75y5UoBQPz555/6ZWPGjBEAxKuvvqpfptVqRf/+/YW9vb24ffu2EEKIv/76SwAQ33//vUFMO3fuLLK8MKadO3cWeT+cnZ3FmDFjSny/Ck2aNEnIZDKDthbG+qjHg/tCrVYLpVJpUG9aWprw8fERL774Yomv/ffffwu5XG5QJj8/X2g0GoNyiYmJQqFQiAULFuiX/fnnnwKAaNCggcjNzTUo36ZNG+Hn5yfS09P1y3bv3i0AiHr16pX6nnTv3r3Edr/yyisGZWfNmiWkUqnYv3+/2LRpkwAgli5dalDG1Ps+PT1duLq6ipCQEJGXl2dQtvCzLYQQ/fv3L7a93377rZBKpeKvv/4yWL5ixQoBQPz9999CiP++H5MmTTIoN3LkSAFAzJ07t6S3UAih228AxEcffSTUarVo1KiRCA4O1sc4d+5cAUDffiF0n+niPrfdu3cX3bt31z8v3P8tW7YUBQUF+uUjRowQEolE9OvXz2D7Tp06lWnfFyc8PFzY29uLhIQE/bKbN28KV1dX8cQTTxTb3tKsXr1aABCLFy8usq7w/Smsz8vLS9y7d0+/fuvWrQKA+O233/TLCt/LBz38Xk6dOlUAEIcOHdIvu3XrlnB3dxcARGJiosG2xR1bFi5cKJydncWFCxcMls+cOVPIZDJx9erVcsdOloGnCG3U8uXLER0dbfDYsWNHueooPDX08K/GU6dOoVatWgaPu3fvAgC2b98OAIiIiDDY5o033gAAbNu2zWB58+bN0alTJ/3zkJAQAMCTTz6JunXrFll++fLlInE+OPi18Gq8goIC7NmzBwCwadMmuLu7o3fv3rhz547+0a5dO7i4uBQ57RYYGIiwsLBHvjclWbduHb744gssWrQIPXv2NFjn4OBQZJ8UPh4mk8n0PWBarRb37t2DWq1G+/btcezYsWJfOyUlBYMHD0abNm3wxRdf6JcrFAp9r59Go8Hdu3fh4uKCJk2aFFvXmDFjDH6BJycnIy4uDmPGjDEYkN67d280b968zO9N/fr1i237wwPG582bhxYtWmDMmDGYNGkSunfvjtdee63YOk2176Ojo5GVlYWZM2fCwcHB4DXKcppo06ZNaNasGZo2bWrwOk8++SQA6F+n8PvxcHuMGTRf2It14sSJCk1d8LDRo0cb9ISEhIRACIEXX3zRoFxISAiuXbsGtVpdrvo1Gg12796N8PBwNGjQQL/cz88PI0eOxIEDB4y6Mvnnn39GzZo18eqrrxZZ9/A+HDZsGGrUqKF/3q1bNwDFH18eZfv27Xj88cfRsWNH/bJatWph1KhRxZYv7tiyadMmdOvWDTVq1DD47ISGhkKj0WD//v2VEjtVPp4itFEdO3as8CB3V1dXAEB2drbB8oYNG+qTgnXr1hmcIrty5QqkUmmRqxV9fX3h4eGBK1euGCx/MIkC/ruiLCAgoNjlD4+bkUqlBgdpAGjcuDEA6OeguXjxIjIyMvSnzB5269Ytg+fFXX1ZFnFxcfjf//6HESNGFEkwAd0fxNDQ0DLXt3btWnzyySc4f/48VCrVI+NTq9UYOnQoNBoNNm/eDIVCoV+n1WqxbNkyfPHFF0hMTNSPYwJQ7Cnjh+sv3GeNGjUqUrakJK04zs7OZWq/vb09Vq9ejQ4dOsDBwQFr1qwpNskx5b4vHKPTsmXLMrXlYRcvXsS5c+dQq1atR75O4ffjwdNVgO59NMaoUaOwcOFCLFiwwGRXt5bnO6nVapGRkVGuoQe3b99Gbm5usW1u1qwZtFotrl27hhYtWpQr7oSEBDRp0qRMA9MfbmNhwlLcuLxHuXLliv7H34NK2p/FfXcvXryIkydPlvrZKWSq2KnyMcGiEhXOT3T69GkMHDhQv9zFxUX/h/LAgQPFblvWAd4lje0qabkoZUBvcbRaLby9vfH9998Xu/7hA5sxV/WkpaXhueeeQ+PGjfHNN9+Ue/uHfffddxg7dizCw8Px5ptvwtvbGzKZDJGRkcUO2H3zzTcRGxuLPXv2FBkX9f7772P27Nl48cUXsXDhQnh6ekIqlWLq1KnFDsa1hKuadu3aBUA3aPnixYtGJ73l3ffG0mq1aNWqlX7c2MMeTk5MpbAXa+zYsdi6dWuxZUr6Lmo0mmK/Z1XxnTQ3c7WluO+WVqtF7969MWPGjGK3KfzRUMiW9oOtY4JFJerWrRvc3d2xYcMGzJo1q0yX6terVw9arRYXL15Es2bN9MtTU1ORnp6uvyrIVLRaLS5fvmxwELpw4QIA6K84CgoKwp49e9ClS5cKJQ8l/aHSarUYNWoU0tPTsWfPHjg5ORn9GoV++uknNGjQAJs3bzZ43blz5xYpu2HDBixduhRLly5F9+7di62rZ8+eWLVqlcHy9PR01KxZs9RYCvfZxYsXi6yLj48vdfvyOnnyJBYsWIBx48YhLi4O48ePx6lTp4rMl2XKfV/Yo3T69OlHzhVX0mcgKCgIJ06cQK9evR7546Lw+1HY21KoIu/j888/j/feew/z58/HM888U2R9jRo1kJ6eXmT5lStXivQAVoVatWrBycmp2DafP38eUqnUqIQ0KCgIhw4dgkqlqrLB3vXq1avw9yIoKAjZ2dnl6t0m68AxWFQiJycnzJgxA6dPn8bMmTOL/YX08LKnnnoKAIpc+VL4y768V0uVxeeff24Qz+effw65XI5evXoBgP7U2cKFC4tsq1ari/3jUxxnZ+diy86fPx+7du3CDz/8YHRPy8MKf6U++P4eOnQIsbGxBuVOnz6N8ePH4/nnn8frr79eYl0P76dNmzbhxo0bZYrFz88Pbdq0wdq1a5GRkaFfHh0djbNnz5apjrJSqVQYO3Ys/P39sWzZMkRFRSE1NRXTpk0rtryp9n2fPn3g6uqKyMhI5OfnG5R78L1zdnY2eA8KDR06FDdu3MDXX39dZF1eXh5ycnIA6OanA4BPP/3UoExFZocv7MWKi4vDr7/+WmR9UFAQ/vnnHxQUFOiX/f7777h27ZrRr1mSq1ev4vz586XG26dPH2zdutXgVjKpqalYv349unbtCjc3t3K/9nPPPYc7d+4YfCYKVVbvzlNPPYV//vkHhw8f1i+7fft2iT2mxRk6dChiY2P1vbYPSk9PL/cYN7Ic7MGyUTt27Cj2QNe5c2eDX61HjhzBe++9V6Rcjx490LVrV8ycORPnzp3DRx99pL9Uv06dOkhLS8OxY8ewadMmeHt76wcGBwcHY8yYMfjqq6+Qnp6O7t274/Dhw1i7di3Cw8OLDPyuKAcHB+zcuRNjxoxBSEgIduzYgW3btuHtt9/Wn/7p3r07XnnlFURGRiIuLg59+vSBXC7HxYsXsWnTJixbtgyDBw8u9bXatWuHPXv2YPHixfD390dgYCCcnJywcOFCPPHEE7h16xa+++47g22MnVjz6aefxubNm/Hss8+if//+SExMxIoVK9C8eXODMXHjxo0DADzxxBNFXrtwXz/99NP6HqHOnTvj1KlT+P7778vVexEZGYn+/fuja9euePHFF3Hv3j189tlnaNGiRZExeiXJyMgoEmOhwvfpvffeQ1xcHGJiYuDq6orWrVtjzpw5ePfddzF48GB9Ag+Ydt+7ublhyZIlGD9+PDp06ICRI0eiRo0aOHHiBHJzc7F27VoAus/Axo0bERERgQ4dOsDFxQUDBgzACy+8gB9//BH/+9//8Oeff6JLly7QaDQ4f/48fvzxR/3cR23atMGIESPwxRdfICMjA507d0ZMTAwuXbpU5n1RnMKxWHFxcUXWjR8/Hj/99BP69u2LoUOHIiEhAd99912RcWCmMHr0aOzbt6/UhOa9995DdHQ0unbtikmTJsHOzg4rV66EUqnEokWLjH7tdevWISIiAocPH0a3bt2Qk5ODPXv2YNKkSQbDHExlxowZ+Pbbb9G3b1+8/vrr+mka6tWrh5MnT5apjjfffBO//vornn76aYwdOxbt2rVDTk4OTp06hZ9++glJSUll6mkmC2SOSxep8jxqmgYAYs2aNfqyjyq3cOFCg3p/+eUX8dRTT4latWoJOzs74eHhIbp27So++ugjg0v3hRBCpVKJ+fPni8DAQCGXy0VAQICYNWuWyM/PNyhXr1490b9//yJtQDHTRxR3ufaYMWOEs7OzSEhIEH369BFOTk7Cx8dHzJ07t8i0BEII8dVXX4l27doJR0dH4erqKlq1aiVmzJghbt68WWpMQghx/vx58cQTTwhHR0cBQIwZM0Z/aXtJj4djLcnDbdZqteL9998X9erVEwqFQrRt21b8/vvvYsyYMQaXxhde+v2ofZ2fny/eeOMN4efnJxwdHUWXLl1EbGxsiZfpb9q0qdgYf/75Z9GsWTOhUChE8+bNxebNm4vEU5JHTdNQ+D4dPXpU2NnZGUy9IIRuyooOHToIf39/kZaWZvB+mnLfCyHEr7/+Kjp37iwcHR2Fm5ub6Nixo/jhhx/067Ozs8XIkSOFh4dHkSkqCgoKxIcffihatGghFAqFqFGjhmjXrp2YP3++yMjI0JfLy8sTr732mvDy8hLOzs5iwIAB4tq1a+WepuFhD373H5ymQQghPvnkE1G7dm2hUChEly5dxJEjR8q8/wvr/ffffw2WFzclROF+Lotjx46JsLAw4eLiIpycnETPnj0Npmwprb3Fyc3NFe+8847+2OPr6ysGDx6snw7iUfU9/P6XZZoGIYQ4efKk6N69u3BwcBC1a9cWCxcuFKtWrSp2moaSji1ZWVli1qxZomHDhsLe3l7UrFlTdO7cWXz88cf6KTPKEztZBokQHBlH1mns2LH46aefytyDQraD+56ILB3HYBERERGZGBMsIiIiIhNjgkVERERkYhyDRURERGRi7MEiIiIiMjEmWEREREQmxolGy0ir1eLmzZtwdXUt8332iIiISDebflZWFvz9/ct02zVbwASrjG7evFlpN2wlIiKqDq5du1bkhvS2iglWGbm6ugLQfTiMuU9WcVQqFXbv3q2/fYctYJusA9tk+WytPQDbZC0qo02ZmZkICAjQ/y2tDphglVHhaUE3NzeTJlhOTk5wc3OzqS8m22T52CbLZ2vtAdgma1GZbapOQ2yqx4lQIiIioirEBIuIiIjIxJhgEREREZkYEywiIiIiE2OCRURERGRiTLCIiIiITIwJFhEREZGJMcEiIiIiMjEmWEREREQmxgSLiIiIyMSYYBERERGZGBMsIiIiIhNjgkVERERkYkywiIiIiEzM4hKsyMhIdOjQAa6urvD29kZ4eDji4+NL3W7Tpk1o2rQpHBwc0KpVK2zfvt1gvRACc+bMgZ+fHxwdHREaGoqLFy9WVjOIiIioGrMzdwAP27dvHyZPnowOHTpArVbj7bffRp8+fXD27Fk4OzsXu83BgwcxYsQIREZG4umnn8b69esRHh6OY8eOoWXLlgCARYsW4dNPP8XatWsRGBiI2bNnIywsDGfPnoWDg0NVNpGIiCyUViugUgoU5Auo8gWUeQ/8P19AlQ8UKAUK8gS0WgGtRoPrZ33wd34eIApQkC/0D5VSlPp66oL75fMECpQCGnUFGyAAtVoXb2EcGlV5qxCQ2gfjqacqGEs1Z3EJ1s6dOw2eR0VFwdvbG0ePHsUTTzxR7DbLli1D37598eabbwIAFi5ciOjoaHz++edYsWIFhBBYunQp3n33XQwcOBAAsG7dOvj4+GDLli0YPnx45TaKiIiqTIFSIDtNi+x0LbLTtMhJ10KZq0WBEijI0/2bl3V/fboWOWla5GZrUZAnoFIa84r1cSkm19TNMCu5xOJOcFkdi0uwHpaRkQEA8PT0LLFMbGwsIiIiDJaFhYVhy5YtAIDExESkpKQgNDRUv97d3R0hISGIjY1lgkVEZEXysrW4l6xBWqoG91I0SEvW4F6qRr8sJ730nqOykCsAewcJ7B0kkN//V+EogVyh+7/MTgKtVoubycnw9/ODzE6qK+8ogcJBAjt7CSSSR7+GnVxXXu4ggb1CApm84nHb2d2v734c5a1TrVZj374/AfhVPJhqzKITLK1Wi6lTp6JLly76U33FSUlJgY+Pj8EyHx8fpKSk6NcXLiupzMOUSiWUyv9+ymRmZgIAVCoVVKpy9reWoLAeU9VnCdgm68A2WT5baw9Q/jblZWtx46IGqYlqpF7RIDVJg1tXNMjJKD2BkskBF3cpnD0kcPaQwsFJcj9ZAuQOEjg465a7uOv+dXLTJST295MnOwUglZaSHd1vS3T0JfTuHQi53ATZkcmVP9lUqbRwcC8w6WfPlj7HZWXRCdbkyZNx+vRpHDhwoMpfOzIyEvPnzy+yfPfu3XBycjLpa0VHR5u0PkvANlkHtsny2Vp7gOLbpC6QIvuWM7JS/nvkpTmWWIfcUQWFmxIO7gVwcFPqHu5KOLgVQOGmhJ1C88jeo4L7j7QcADkAbpi+TdbOlG3KzbWtU6hlYbEJ1pQpU/D7779j//79qFOnziPL+vr6IjU11WBZamoqfH199esLl/n5+RmUadOmTbF1zpo1y+C0Y2ZmJgICAtCnTx+4ubkZ06QidL98otG7d28L/eVTfmyTdWCbLJ+ttQcwbFNepgzxhwuQcFyF6xc0uH1VA1FMZ4unnxR+DWTwqW8H73oy+NSXoWYdGRSOpfcuVQVb30+malPhWaDqxOISLCEEXn31Vfzyyy/Yu3cvAgMDS92mU6dOiImJwdSpU/XLoqOj0alTJwBAYGAgfH19ERMTo0+oMjMzcejQIUycOLHYOhUKBRQKRZHlcrnc5F+iyqjT3Ngm68A2WT5baY8QAlfOqpCwLwDxm3OQnKApUsbDW4qAJnIENJMjoKkcAU3kcHa3jsHWtrKfHmTKNtnae1MWFpdgTZ48GevXr8fWrVvh6uqqHyPl7u4OR0ddd/Ho0aNRu3ZtREZGAgBef/11dO/eHZ988gn69++PDRs24MiRI/jqq68AABKJBFOnTsV7772HRo0a6adp8Pf3R3h4uFnaSURUHdy5ocaRXfk4ujsPd65rAPgD0J2+C2gqR5MO9qjXUpdMuXnJzB0ukclYXIL15ZdfAgB69OhhsHzNmjUYO3YsAODq1auQSv/7VdO5c2esX78e7777Lt5++200atQIW7ZsMRgYP2PGDOTk5ODll19Geno6unbtip07d3IOLCIiEyvIF4j7Mx///JqLxFP/DW6WOwA1Au+g16D6aP64E1xqWEfvFJExLC7BEsWdhH/I3r17iywbMmQIhgwZUuI2EokECxYswIIFCyoSHhERlSD5sgqxv+bhyM485GXrjuUSKdC4vT3ahzmiaScZYv48hLahTSCXM7ki22ZxCRYREVmXhBMF2LMuG+cPFeiXefrJ8PgAR3R8yhHuNXWn/qrjpfpUfTHBIiKichNC4Pw/BYj+NhuJJ3WJk0QKtOqmQKeBTmjc3r5M80gR2SomWEREVC63r6mx6eNMXDyq67GSyYGO/Rzx5Chn1KzNPytEABMsIiIqI7VK4M/1Odi9NhvqAkBuD3R51gk9RjjrTwMSkQ4TLCIiKtWVMwXY8EEmUhLVAIDGHewxZLobe6yISsBvBhERlUir1fVabf86G1oN4OIhRfhrrnistwMkpd3JmKgaY4JFRETFyrqnwffvZSD+sG6sVdteDnjuDTc4u3GKBaLSMMEiIqIiLhxR4ruFGci6q4VcAQya6oaQpx3Za0VURkywiIjIwF8/5+CXZVkQWsA30A6j57vDr0H1u5ccUUUwwSIiIgCARi2w5dMsHNicCwBo39cBQ6a7w96BvVZE5cUEi4iIkJetxdo56Yg/XACJBOj/Pxc8OdKZpwSJjMQEi4iomsu4o8GXU9OQmqSGvYMEo2a7o3V3B3OHRWTVmGAREVVj2elafXLlXkuK8R/WQJ3GHG9FVFFMsIiIqqm8bC1WvnFPl1zVlOLV5Z7w8uefBSJT4GQmRETVkDJPi69npOF6vBrOHhJMXMrkisiUmGAREVUz6gKBNe+kI/GkCg4uEvxvsSd86jO5IjIlJlhERNXMT4szEX+4APaOErz8EcdcEVUGJlhERNXIP7/n4tDveZBIgLELPRDYyt7cIRHZJCZYRETVxPULKvy8OBMA0G+8C5o9rjBzRES2iwkWEVE1kJupxZp30qEuAJp3VqDXC87mDonIpjHBIiKycVqtwPfvZeBesgaefjKMetcdUilnaCeqTEywiIhs3B/f5+DsQSXs7IFx/+cBJzce+okqG79lREQ27MZFFXauygYAPBfhxisGiaoIEywiIhulVgmsfy8DGjXQqpsCIf0dzR0SUbXBBIuIyEbtXpONmwm6mdqHvOkGiYTjroiqChMsIiIbdOVsAWK+zwEADH7DHa6eMjNHRFS9MMEiIrIxBUqB9f+XAa0GeCzUAW16Opg7JKJqhwkWEZGN2fF1Fm5d0cDVS4pBEW7mDoeoWmKCRURkQ1IS1di/KRcAMGyGG5w5JQORWfCbR0RkQ379Igtaje6qwRZdeGqQyFyYYBER2Yj4f5U4F6uEVAYMmORq7nCIqjUmWERENkCrEdj6eRYAoOtzTqgVYGfmiIiqNyZYREQ24PD2PCQnqOHkKkGfsS7mDoeo2mOCRURk5fJztdj+te52OH3GuXBgO5EF4LeQiMjK/fFdDrLuaVGzjgxdnnUydzhEBCZYRERWLeOOBns36GZsf2aSK+zkvB0OkSVggkVEZMX2/ZgLVQFQv5UcLbspzB0OEd1ncQnW/v37MWDAAPj7+0MikWDLli2PLD927FhIJJIijxYtWujLzJs3r8j6pk2bVnJLiIgqV26mFgd/0U0qGvqCM2/mTGRBLC7BysnJQXBwMJYvX16m8suWLUNycrL+ce3aNXh6emLIkCEG5Vq0aGFQ7sCBA5URPhFRlTmwORfKPAG/IDs078TeKyJLYnETpfTr1w/9+vUrc3l3d3e4u7vrn2/ZsgVpaWkYN26cQTk7Ozv4+vqaLE4iInMqyBfY/5Nu7FWvUey9IrI0FpdgVdSqVasQGhqKevXqGSy/ePEi/P394eDggE6dOiEyMhJ169YtsR6lUgmlUql/npmZCQBQqVRQqVQmibWwHlPVZwnYJuvANlm+0tpzcGsectIFPP2laPGEzCrabWv7CGCbyltndSIRQghzB1ESiUSCX375BeHh4WUqf/PmTdStWxfr16/H0KFD9ct37NiB7OxsNGnSBMnJyZg/fz5u3LiB06dPw9W1+NtJzJs3D/Pnzy+yfP369XBy4mXQRGQ+Wo0Eh74JhjJTgUa9E1G7zS1zh0T0SLm5uRg5ciQyMjLg5uZm7nCqhE0lWJGRkfjkk09w8+ZN2Nvbl1guPT0d9erVw+LFi/HSSy8VW6a4HqyAgADcuXPHZB8OlUqF6Oho9O7dG3K53CR1mhvbZB3YJsv3qPYc2ZmPHz/MgUsNCWZtqAG5vXWcHrS1fQSwTWWVmZmJmjVrVqsEy2ZOEQohsHr1arzwwguPTK4AwMPDA40bN8alS5dKLKNQKKBQFB00KpfLTf4lqow6zY1tsg5sk+V7uD1arcC+jfkAgB7DnOHk/OjjnSWytX0EsE1lqau6sbirCI21b98+XLp0qcQeqQdlZ2cjISEBfn5+VRAZEZHpnD2oRGqSBg4uEs7aTmTBLC7Bys7ORlxcHOLi4gAAiYmJiIuLw9WrVwEAs2bNwujRo4tst2rVKoSEhKBly5ZF1k2fPh379u1DUlISDh48iGeffRYymQwjRoyo1LYQEZna35t18151esYJDs4Wdwgnovss7hThkSNH0LNnT/3ziIgIAMCYMWMQFRWF5ORkfbJVKCMjAz///DOWLVtWbJ3Xr1/HiBEjcPfuXdSqVQtdu3bFP//8g1q1alVeQ4iITOzODTXOHy4AAHQe6GjmaIjoUSwuwerRowceNe4+KiqqyDJ3d3fk5uaWuM2GDRtMERoRkVnFbs0DADTtaI+atS3u8E1ED2D/MhGRFVAXCBzarvsh2Zljr4gsHhMsIiIrcGJvPnLSBTy8pbwtDpEVYIJFRGQF/t6i6716fIATZHbWMe8VUXXGBIuIyMLdTFAh8aQKUhnw+AAObieyBkywiIgs3MEtusHtLbsq4F5TZuZoiKgsmGAREVkwZZ7AkV26BKtzOAe3E1kLJlhERBYsLkYJZa5ArToyNGpnfbfFIaqumGAREVmwo7t0N51//BknSKUc3E5kLZhgERFZqLwMeySdVkMiAR7r7WDucIioHJhgERFZqFvnagIAGj5mD49aHNxOZE2YYBERWahb57wAsPeKyBoxwSIiskDJl9XIueMEmRwI7s4Ei8jaMMEiIrJAx/foBrc3e9wejq48VBNZG35riYgsjFYrEPdHAQCgTS9OzUBkjZhgERFZmKRTKqSnaiGz16DZ40ywiKwREywiIgtzLFo3c3utxvcgV3DuKyJrxASLiMiCaNQCcX/mAwC8m90xczREZCwmWEREFuT8YSVyMgRcakjgUTfT3OEQkZGYYBERWZBj0breqzZPKiDlEZrIavHrS0RkIdQFAmf+1k3PEPwkB7cTWTMmWEREFuLS8QIocwXcvKQIaGpn7nCIqAKYYBERWYhTf+lOD7boqoBUyqsHiawZEywiIgug1QqcOaA7PdiqK2+NQ2TtmGAREVmA6/FqZNzRQuEoQaN2HH9FZO2YYBERWYDT908PNn1cATt7nh4ksnZMsIiILMCpv+6fHuymMHMkRGQKFbpMZdeuXVi1ahUuX76MtLQ0CCEM1kskEiQkJFQoQCIiW3fnhhopiWpIZUCzx5lgEdkCoxOsjz76CDNnzoSPjw86duyIVq1amTIuIqJq4/T93qugNvZwcuOJBSJbYHSCtWzZMjz55JPYvn075HK5KWMiIqpWTh/Qjb9q2ZW9V0S2wuifSmlpaRg8eDCTKyKiCshO1+LySRUAoGU3Ts9AZCuMTrA6duyI+Ph4U8ZCRFTtnD2YD6EFajeyg6evzNzhEJGJGJ1gffHFF9i8eTPWr19vyniIiKqVwvFXPD1IZFuMHoM1bNgwqNVqvPDCC5g4cSLq1KkDmczw15dEIsGJEycqHCQRkS1SKQXi/y0AwNODRLbG6ATL09MTXl5eaNSokSnjISKqNi6fLEBBvoB7TSlqN+LNnYlsidHf6L1795owDCKi6ufC/d6rxh3sIZFw9nYiW8IJV4iIzCT+X934qyYdOP6KyNZUKMHKzMzEBx98gLCwMLRt2xaHDx8GANy7dw+LFy/GpUuXyl3n/v37MWDAAPj7+0MikWDLli2PLL93715IJJIij5SUFINyy5cvR/369eHg4ICQkBB9rERE5pB1T4MbF9UAdD1YRGRbjE6wrl+/jrZt22LOnDm4fv06Tp48iezsbAC68VkrV67EZ599Vu56c3JyEBwcjOXLl5dru/j4eCQnJ+sf3t7e+nUbN25EREQE5s6di2PHjiE4OBhhYWG4detWueMjIjKFC0d0pwdrN7KDaw1Oz0Bka4weg/Xmm28iKysLcXFx8Pb2NkhoACA8PBy///57uevt168f+vXrV+7tvL294eHhUey6xYsXY8KECRg3bhwAYMWKFdi2bRtWr16NmTNnlvu1iIgqiqcHiWyb0T1Yu3fvxmuvvYbmzZsXOzizQYMGuHbtWoWCK482bdrAz88PvXv3xt9//61fXlBQgKNHjyI0NFS/TCqVIjQ0FLGxsVUWHxFRISGEwQB3IrI9Rvdg5eXloVatWiWuz8rKMrbqcvHz88OKFSvQvn17KJVKfPPNN+jRowcOHTqExx57DHfu3IFGo4GPj4/Bdj4+Pjh//nyJ9SqVSiiVSv3zzMxMAIBKpYJKpTJJ7IX1mKo+S8A2WQe2ybxSEtXIuKOFnT0Q0FxSbMzW1J6yYpusQ2W0yZben7IyOsFq3rw59u/fj1deeaXY9Vu2bEHbtm2NDqysmjRpgiZNmuifd+7cGQkJCViyZAm+/fZbo+uNjIzE/PnziyzfvXs3nJycjK63ONHR0SatzxKwTdaBbTKPa0d8AdSDq386ovccemRZa2hPebFN1sGUbcrNzTVZXdbC6ARr6tSpGDNmDFq3bo0hQ4YAALRaLS5duoT58+cjNjYWP//8s8kCLY+OHTviwIEDAICaNWtCJpMhNTXVoExqaip8fX1LrGPWrFmIiIjQP8/MzERAQAD69OkDNzc3k8SpUqkQHR2N3r1728xNs9km68A2mdeq/ZkAVOjczx/dnwoqtow1taes2CbrUBltKjwLVJ0YnWA9//zzuHLlCt5991288847AIC+fftCCAGpVIr3338f4eHhpoqzXOLi4uDn5wcAsLe3R7t27RATE6OPR6vVIiYmBlOmTCmxDoVCAYWi6OBTuVxu8i9RZdRpbmyTdWCbqp66QOBynO50SfPHHUuN1dLbYwy2yTqYsk229t6URYXuzfDOO+/ghRdewM8//4xLly5Bq9UiKCgIgwYNQoMGDYyqMzs722D+rMTERMTFxcHT0xN169bFrFmzcOPGDaxbtw4AsHTpUgQGBqJFixbIz8/HN998gz/++AO7d+/W1xEREYExY8agffv26NixI5YuXYqcnBz9VYVERFUl8XQBVErA1UsKvwa8PQ6RrTLq252bm4tu3bphwoQJ+N///odp06aZLKAjR46gZ8+e+ueFp+nGjBmDqKgoJCcn4+rVq/r1BQUFeOONN3Djxg04OTmhdevW2LNnj0Edw4YNw+3btzFnzhykpKSgTZs22LlzZ5GB70RElS3+sO7qwSbteXscIltmVILl5OSExMTESjk49OjRA0KIEtdHRUUZPJ8xYwZmzJhRar1Tpkx55ClBIqKqUDj/VWPOf0Vk04yeB6tv377YtWuXKWMhIrJp2ela3Lhw//Y47Tn/FZEtMzrBmj17Ni5cuIAXXngBBw4cwI0bN3Dv3r0iDyIi0rl0rABCAH5BdnCvydvjENkyo0dYtmjRAgBw9uxZrF+/vsRyGo3G2JcgIrIpCXG68VcN27L3isjWGZ1gzZkzhwM0iYjKoTDBCmrDBIvI1hmdYM2bN8+EYRAR2bacDC2SL+vGXwUFM8EisnVGj8EiIqKyu3xC13vlU98OLjV46CWydWXuwVqwYEG5K5dIJJg9e3a5tyMisjWX9KcHq9+M1kTVUZkTrOJOCRaOwXp43iqJRAIhBBMsIqL7OP6KqHopcz+1Vqs1eFy7dg2tWrXCiBEjcPjwYWRkZCAjIwOHDh3C8OHDERwcjGvXrlVm7EREViEvS4ubF++Pv2KCRVQtGD0QYPLkyWjUqBG+++47tG/fHq6urnB1dUWHDh3w/fffIygoCJMnTzZlrEREVunySd38V7XqyDj/FVE1YXSC9ccff+DJJ58scX2vXr0QExNjbPVERDYj4YQKABDE+a+Iqg2jEywHBwfExsaWuP7gwYNwcHAwtnoiIpuRcFw3/qoBp2cgqjaMTrBGjRqF77//Hq+99houXryoH5t18eJFvPrqq1i/fj1GjRplyliJiKxOfq4W1y/oerAacvwVUbVh9ESjH374Ie7cuYPPP/8cy5cvh1Sqy9W0Wi2EEBgxYgQ+/PBDkwVKRGSNkk6poNUAnn4y1PDl+Cui6sLoBMve3h7ffvst3nzzTWzfvh1XrlwBANSrVw/9+vVDcHCwyYIkIrJWCZz/iqhaMjrBKtS6dWu0bt3aFLEQEdmcS5z/iqha4v0aiIgqSUG+wLVz968gZIJFVK2UuQdLKpXqZ24vK4lEArVaXe6giIhswZUzBdCoAfdaUnj5c/wVUXVS5gRrzpw55U6wiIiqswdvj8PjJ1H1UqF7ERIRUckST+tODwa24ulBouqGY7CIiCqBVitw9WxhgsUrCImqmzL3YK1btw4A8MILL0Aikeifl2b06NHGRUZEZMVSk9TIzxGwd5TAN7DCF2wTkZUp87d+7NixkEgkGD58OOzt7TF27NhSt5FIJEywiKhaSrp/erBuMzlkdhx/RVTdlDnBSkxMBKCbYPTB50REVFRhglW/BU8PElVHZU6w6tWr98jnRET0n6TTuisI63P8FVG1xEHuREQmlpOpxa2rGgBA/Ra8gpCoOqrQyMtdu3Zh1apVuHz5MtLS0iCEMFgvkUiQkJBQoQCJiKzNlTO604O1AmRwdufvWKLqyOgE66OPPsLMmTPh4+ODjh07olWrVqaMi4jIaulPD7bk6UGi6sroBGvZsmV48sknsX37dsjlPIgQERXSD3BvydODRNWV0X3XaWlpGDx4MJMrIqIHaDX/TTDKHiyi6svoBKtjx46Ij483ZSxERFYv+bIayjwBhZMEvvU5wShRdWV0gvXFF19g8+bNWL9+vSnjISKyakn3B7jXay6HVMYJRomqqzL/vGrdunWRZWq1Gi+88AImTpyIOnXqQCaTGayXSCQ4ceJExaMkIrISSac4/xURlSPB8vT0hERi+GvMy8sLjRo1MnlQRETWqrAHi/NfEVVvZU6w9u7dW4lhEBFZv+w0Le5c100wWq85e7CIqjPOgEdEZCJJZ3SnB33qy+DkxsMrUXVm9BHghx9+wNixY0tcP27cOPz444/GVk9EZHU4/xURFTI6wVqyZAkUCkWJ6x0dHbFkyZJy17t//34MGDAA/v7+kEgk2LJlyyPLb968Gb1790atWrXg5uaGTp06YdeuXQZl5s2bB4lEYvBo2rRpuWMjInqUwlvkcP4rIjI6wYqPj0fbtm1LXB8cHIzz58+Xu96cnBwEBwdj+fLlZSq/f/9+9O7dG9u3b8fRo0fRs2dPDBgwAMePHzco16JFCyQnJ+sfBw4cKHdsREQl0WoErsXrEqy6zZhgEVV3Rs+CJ4RAenp6ievT0tKgUqnKXW+/fv3Qr1+/MpdfunSpwfP3338fW7duxW+//WaQANrZ2cHX17fc8RARlcWtqxoocwXsHTnBKBFVIMFq27YtfvjhB0RERMDe3nC8gVKpxPr16x/Zw1VZtFotsrKy4OnpabD84sWL8Pf3h4ODAzp16oTIyEjUrVu3xHqUSiWUSqX+eWZmJgBApVIZlTgWp7AeU9VnCdgm68A2mV7i6XwAQO1GMmi0ami0FavP3O2pDGyTdaiMNtnS+1NWEiGEMGbDHTt24Omnn8bjjz+OmTNnokWLFgCA06dPIzIyEocPH8avv/6K/v37Gx+cRIJffvkF4eHhZd5m0aJF+OCDD3D+/Hl4e3vrY83OzkaTJk2QnJyM+fPn48aNGzh9+jRcXV2LrWfevHmYP39+keXr16+Hk5OTUe0hItt1Ibo+bsb5oE77ZDTsedXc4RBZlNzcXIwcORIZGRlwc3MzdzhVwugECwCioqLw+uuvIzs7W79MCAFXV1csWbIEL774YsWCK2eCtX79ekyYMAFbt25FaGhoieXS09NRr149LF68GC+99FKxZYrrwQoICMCdO3dM9uFQqVSIjo5G7969beam2WyTdWCbTO+ziem4dl6DkbNd0ObJki8AKitzt6cysE3WoTLalJmZiZo1a1arBKtCAwXGjh2LQYMGITo6GgkJCQCAoKAg9OnTp8SeocqyYcMGjB8/Hps2bXpkcgUAHh4eaNy4MS5dulRiGYVCUexVknK53ORfosqo09zYJuvANpmGukDg5iXdBKOBLR0gl5tuDBb3kXVgm0qvq7qp8FHAzc0Nzz33nCliMdoPP/yAF198ERs2bCjTKcns7GwkJCTghRdeqILoiMjW3UxQQ6MGnN0l8PKXlb4BEdk8i7vUJTs726BnKTExEXFxcfD09ETdunUxa9Ys3LhxA+vWrQOgOy04ZswYLFu2DCEhIUhJSQGgm4fL3d0dADB9+nQMGDAA9erVw82bNzF37lzIZDKMGDGi6htIRDbn6jndAN6ApvIi92wlourJ4u7lcOTIEbRt21Z/BWJERATatm2LOXPmAACSk5Nx9ep/A0i/+uorqNVqTJ48GX5+fvrH66+/ri9z/fp1jBgxAk2aNMHQoUPh5eWFf/75B7Vq1araxhGRTbp6TneLHM5/RUSFLK4Hq0ePHnjUuPuoqCiD52W5CfWGDRsqGBURUcmunlMDYIJFRP+xuB4sIiJrkp+rxa0rTLCIyFCZE6xBgwbhr7/+0j/fv38/bt++XSlBERFZi+vnVRACqOEjhasnB7gTkU6ZE6ytW7cajH3q2bMnoqOjKyUoIiJrcaVwgDt7r4joAWVOsGrXrm1wA2UhBK+WIaJq79r9BKtuUyZYRPSfMg9yHz58OD7++GP8+OOP8PDwAADMnDkTkZGRJW4jkUhw4sSJCgdJRGSpCqdoqNucCRYR/afMCVZkZCQaNmyIP//8E7du3YJEIoGzszO8vLwqMz4iIouVlaZBWqoWEgkQ0IQJFhH9p8wJlkwmw8svv4yXX34ZACCVSvHuu+9i5MiRlRYcEZElK+y98q4ng4MzL8omov8YPQ9WYmIiJ+okomrtwRnciYgeZHSCVa9ePQC6RGvHjh24cuWKfnm/fv0QGBhomgiJiCyUfoA7ryAkoodUaCb3N954A8uWLYNWqzVYLpVKMXXqVHz88ccVCo6IyFIJIXD1PK8gJKLiGT1o4JNPPsGSJUswaNAgxMbGIj09Henp6YiNjcXgwYOxZMkSLFmyxJSxEhFZjLRULXLSBaQywL8hEywiMmR0D9bXX3+NZ555Bj/++KPB8pCQEGzYsAH5+flYuXIlpk2bVuEgiYgszfV4Xe+VXwM7yBWcE5CIDBndg5WUlISwsLAS14eFhSEpKcnY6omILNq1+6cH63B6BiIqhtEJlre39yMnET1x4gSvMiQim3Xtfg8W578iouIYnWANGTIE33zzDT744APk5OTol+fk5ODDDz/EN998g2HDhpkkSCIiSyKE0J8i5BQNRFQco8dgLVy4EHFxcXj77bcxZ84c+Pv7AwBu3rwJtVqNnj17YsGCBSYLlIjIUqSlapGToRvg7tegQhdjE5GNMvrI4OTkhJiYGGzdutVgHqy+ffviqaeewoABA3gzaCKySRzgTkSlqfBPr4EDB2LgwIGmiIWIyCpwgDsRlYY3zyIiKicOcCei0jDBIiIqBw5wJ6KyYIJFRFQOHOBORGXBBIuIqBw4wJ2IyoIJFhFROXCAOxGVBRMsIqJy4AB3IiqLShlAkJmZiS1btgAARo8eXRkvQURU5R4c4F6nCcdfEVHJKuUIkZycjLFjx0IikTDBIiKb8eAAd/8g9mARUckqJcHy8/PDmjVrKqNqIiKz4QB3IiqrSkmw3NzcMGbMmMqomojIbDjAnYjKioPciYjKiAPciaisKtyDtX//fly+fBlpaWkQQhisk0gkmDZtWkVfgojI7DjAnYjKw+ijRFxcHIYNG4ZLly4VSawKMcEiIlvBAe5EVB5GJ1jjx4/HrVu3sGLFCoSEhMDd3d2UcRERWZTC3ivfQA5wJ6LSGZ1gnTlzBgsWLMCECRNMGQ8RkUW6foHjr4io7Iwe5N6oUSNIJPwVR0TVw/ULagBAncYcf0VEpTM6wZo3bx6WL1+OGzdumDIeIiKLVNiDxSkaiKgsjP4pNmjQIOTn56NJkybo1asX6tSpA5lMZlBGIpFg2bJlFQ6SiMicMu5okHVXC4kU8AtiDxYRlc7oHqx9+/Zh4sSJyM3NxW+//YYvv/wSn3/+eZFHee3fvx8DBgyAv78/JBKJ/p6Gj7J371489thjUCgUaNiwIaKiooqUWb58OerXrw8HBweEhITg8OHD5Y6NiKqnwt4r77p2UDhy+kAiKp3RR4pXX30Vbm5u2LVrF9LT06HVaos8NBpNuevNyclBcHAwli9fXqbyiYmJ6N+/P3r27Im4uDhMnToV48ePx65du/RlNm7ciIiICMydOxfHjh1DcHAwwsLCcOvWrXLHR0TVz/X4++OvOP8VEZWR0UeLS5cu4YMPPkDv3r1NGQ/69euHfv36lbn8ihUrEBgYiE8++QQA0KxZMxw4cABLlixBWFgYAGDx4sWYMGECxo0bp99m27ZtWL16NWbOnGnS+InI9ujHXzXm+CsiKhujE6wWLVogIyPDlLEYJTY2FqGhoQbLwsLCMHXqVABAQUEBjh49ilmzZunXS6VShIaGIjY2tsR6lUollEql/nlmZiYAQKVSQaVSmST2wnpMVZ8lYJusA9tUPvo5sBpIquw94z6yDmxT+eqsToxOsD7++GOMGjUKYWFh6NixoyljKpeUlBT4+PgYLPPx8UFmZiby8vKQlpYGjUZTbJnz58+XWG9kZCTmz59fZPnu3bvh5ORkmuDvi46ONml9loBtsg5sU+kKcu2QfqsdAOBM4h+Iv1n+oQ8VwX1kHdimR8vNzTVZXdbC6ATrk08+gaurKzp16oTmzZujbt26xV5FuHXr1goHaQ6zZs1CRESE/nlmZiYCAgLQp08fuLm5meQ1VCoVoqOj0bt3b8jltnHqgW2yDmxT2V34twAHkYWadaR45tkwk9VbGu4j68A2lU3hWaDqxOgE6+TJk5BIJKhbty6ys7Nx9uzZImWqYiJSX19fpKamGixLTU2Fm5sbHB0dIZPJIJPJii3j6+tbYr0KhQIKhaLIcrlcbvIvUWXUaW5sk3Vgm0qXnKAbKhDQxN4s7xX3kXVgm0qvq7oxOsFKSkoyYRjG69SpE7Zv326wLDo6Gp06dQIA2Nvbo127doiJiUF4eDgAQKvVIiYmBlOmTKnqcInIyhTO4F6bM7gTUTlY3IQu2dnZiIuLQ1xcHADdNAxxcXG4evUqAN2pu9GjR+vL/+9//8Ply5cxY8YMnD9/Hl988QV+/PFHTJs2TV8mIiICX3/9NdauXYtz585h4sSJyMnJ0V9VSERUkhu8gpCIjGD0T7LChKc0devWLVe9R44cQc+ePfXPC8dBjRkzBlFRUUhOTjZ47cDAQGzbtg3Tpk3DsmXLUKdOHXzzzTf6KRoAYNiwYbh9+zbmzJmDlJQUtGnTBjt37iwy8J2I6EF5WVrcuaEb1M4Ei4jKw+gEq379+mUaY1XeyUZ79OgBIUSJ64ubpb1Hjx44fvz4I+udMmUKTwkSUbncuKjrvarhK4Wzu8V1+BORBTM6wVq9enWRBEuj0SApKQnr1q2Dt7c3Jk+eXOEAiYjMpXD8FXuviKi8jE6wxo4dW+K6t956CyEhIRYxESkRkbE4gzsRGatS+rydnZ0xbtw4LFmypDKqJyKqEvoEqwkTLCIqn0obVKDVapGSklJZ1RMRVSplrha3rhQOcOcUDURUPiY/amRmZmL//v346KOP0LZtW1NXT0RUJW5cUkMIwM1LCjcvWekbEBE9wOgESyqVlngVoRACdevWxRdffGF0YERE5sTTg0RUEUYnWHPmzCmSYEkkEtSoUQNBQUHo06cP7OzYrU5E1ulG4RWETXgcI6LyM/rIMW/ePBOGQURkWa7F8wpCIjIeZ84jInpIgVIgNYlzYBGR8crVg7V48eJyv0DhrW6IiKxFcoIKWg3g4iGFhzd/hxJR+ZUrwZo+fXqZyj04NosJFhFZm+vxhb1XdmW6JRgR0cPKlWAlJiaWWub48eNYsGAB4uLi4OHhYWxcRERmwysIiaiiypVg1atXr8R1J06cwPz587F161a4u7tj7ty5mDp1akXjIyKqctfjmWARUcVU+PrjuLg4zJ8/H7/++qtBYuXm5maK+IiIqpS6QCD58n+nCImIjGH00SMuLg7z5s3Db7/9Bg8PD8ybNw+vv/46EysismrJiWpo1ICTqwSefpzBnYiMU+4E6/jx4/oeqxo1ajCxIiKbcuP++KvajeUc4E5ERitXgjVw4ED8/vvvqFGjBhYuXIjXX38dLi4ulRUbEVGVu8bxV0RkAuVKsH777TdIJBK4urpi48aN2Lhx4yPLSyQSnDhxokIBEhFVpcIpGgJ4ixwiqoByHUGeeOIJdpkTkc3SqAVuJvAWOURUceVKsPbu3VtJYRARmV9qkhrqAkDhJIFXbQ5wJyLj8R4QRET36ScYbWwHqZS99URkPCZYRET3Xb9wf/4rDnAnogpigkVEdJ/+CkKOvyKiCmKCRUQEQKsRuHmx8ApCJlhEVDFMsIiIANy+pkFBvoC9owS1AjjAnYgqhgkWERH+Oz1Yu6EdpDIOcCeiimGCRUSEB64g5OlBIjKBMs+DFRgYWO5JRiUSCRISEsodFBFRVbt2/r8pGoiIKqrMR5Lu3bsXSbCOHDmCM2fOoHnz5mjSpAkAID4+HmfPnkXLli3Rrl0700ZLRFQJtBqhn6IhoCl7sIio4sqcYEVFRRk837JlC7Zs2YLo6Gj06tXLYF10dDSGDh2KhQsXmiRIIqLKdOuqBgV5ugHuPvXYg0VEFWf0GKw5c+bg1VdfLZJcAUDv3r0xZcoUvPvuuxUKjoioKjx4epAD3InIFIxOsC5evAgvL68S13t5eXH8FRFZhav3EyyeHiQiUzE6wQoKCsKaNWuQnZ1dZF1WVhZWr16NBg0aVCg4IqKqUNiDVZcJFhGZiNGDDd577z0MHjwYTZs2xdixY9GwYUMAup6ttWvXIjU1FZs2bTJZoERElUGjFrh5kT1YRGRaRidY4eHh2L59O9566y28//77BuvatGmDVatWISwsrMIBEhFVppRENVQFgIOLBF61OYM7EZlGhS6X6dOnD/r06YOUlBRcuXIFAFCvXj34+vqaJDgiospWeHowoIkcUikHuBORaZhkJndfX1+EhIQgJCTEZMnV8uXLUb9+fTg4OCAkJASHDx8usWyPHj0gkUiKPPr3768vM3bs2CLr+/bta5JYich6cYA7EVWGCiVYV69exf/+9z80adIEnp6e2L9/PwDgzp07eO2113D8+HGj6t24cSMiIiIwd+5cHDt2DMHBwQgLC8OtW7eKLb9582YkJyfrH6dPn4ZMJsOQIUMMyvXt29eg3A8//GBUfERkO66dY4JFRKZn9CnCs2fPolu3btBqtQgJCcGlS5egVutmQq5ZsyYOHDiAnJwcrFq1qtx1L168GBMmTMC4ceMAACtWrMC2bduwevVqzJw5s0h5T09Pg+cbNmyAk5NTkQRLoVDw9CUR6amUAsmXdcetuk05wSgRmY7RPVgzZsyAh4cHLly4gO+++w5CCIP1/fv3x19//VXuegsKCnD06FGEhob+F6RUitDQUMTGxpapjlWrVmH48OFwdnY2WL537154e3ujSZMmmDhxIu7evVvu+IjIdiRfVkOjBpw9JKjhywHuRGQ6Rv9k279/P+bMmYNatWoVm6jUrVsXN27cKHe9d+7cgUajgY+Pj8FyHx8fnD9/vtTtDx8+jNOnTxfpOevbty8GDRqEwMBAJCQk4O2330a/fv0QGxsLmazogVWpVEKpVOqfZ2ZmAgBUKhVUKlW521WcwnpMVZ8lYJusA9ukk3QmH4BuBvfCHnhLwX1kHdim8tVZnRidYGm1Wjg5OZW4/vbt21AoFMZWb7RVq1ahVatW6Nixo8Hy4cOH6//fqlUrtG7dGkFBQdi7d2+xt/uJjIzE/PnziyzfvXv3I9ttjOjoaJPWZwnYJutQ3dt0fk8gAG/ky5Kwffv1yguqAqr7PrIWbNOj5ebmmqwua2F0gvXYY49h27ZtmDRpUpF1arUaGzZswOOPP17uemvWrAmZTIbU1FSD5ampqaWOn8rJycGGDRuwYMGCUl+nQYMGqFmzJi5dulRsgjVr1ixERETon2dmZiIgIAB9+vSBm5tbGVvzaCqVCtHR0ejduzfkctsYYMs2WQe2Sef8z+kANOjRvyladGldqfGVF/eRdWCbyqbwLFB1YnSCNWvWLDz99NOYOHGivncoNTUVe/bswfvvv49z587h888/L3e99vb2aNeuHWJiYhAeHg5A11sWExODKVOmPHLbTZs2QalU4vnnny/1da5fv467d+/Cz8+v2PUKhaLYHji5XG7yL1Fl1GlubJN1qM5tKsgXSE3SAAACWzpALrfMMVjVeR9ZE7ap9LqqG6MTrH79+iEqKgqvv/46vvrqKwDA888/DyEE3NzcsG7dOjzxxBNG1R0REYExY8agffv26NixI5YuXYqcnBz9VYWjR49G7dq1ERkZabDdqlWrEB4eXuQm1NnZ2Zg/fz6ee+45+Pr6IiEhATNmzEDDhg052zxRNXX9ggpCC7h5SeFe0zKTKyKyXhW6LvmFF17AoEGDEB0djYsXL0Kr1SIoKAhhYWFwdXU1ut5hw4bh9u3bmDNnDlJSUtCmTRvs3LlTP/D96tWrkEoNL4CMj4/HgQMHsHv37iL1yWQynDx5EmvXrkV6ejr8/f3Rp08fLFy40CzjxIjI/PQ3eG5W/X5ZE1Hlq9BVhM2aNUOtWrX0p/IedOfOHZw9e9boXqwpU6aUeEpw7969RZY1adKkyFQRhRwdHbFr1y6j4iAi23QtnhOMElHlMXoerJ49ez7yCoOYmBj07NnT2OqJiCqVfgb3JkywiMj0jE6wSuotKqRUKoudX4qIyNxyM7W4dVU3wL1ucyZYRGR65TpFePXqVSQlJemfnz9/Xn//wQelp6dj5cqVqFevXoUDJCIytav3e69q1ZHB2d0k97wnIjJQrgRrzZo1mD9/PiQSCSQSCf7v//4P//d//1eknBACMpkMK1euNFmgRESmknTm/gD3Fuy9IqLKUa4Ea+jQoWjZsiWEEBg6dChee+01dOvWzaCMRCKBs7Mz2rRpU+R2N0REluDKmQIAQH2eHiSiSlKuBKtZs2Zo1qwZAF1v1hNPPIHAwMBKCYyIqDIIIXD1rK4Hq14LezNHQ0S2yujBB6NGjSoyoeeDMjMzLe7mqUREt69pkJslILcH/BtWaCpAIqISGZ1gvfbaa+jcuXOJ67t06YI33njD2OqJiCrFlfvjr+o0kUNmJzFzNERkq4xOsHbu3InBgweXuH7w4MHYvn27sdUTEVWKwvFX9TjAnYgqkdEJ1s2bN1G7du0S1/v7++PGjRvGVk9EVCmSOP6KiKqA0QmWl5cX4uPjS1x/7tw5uLm5GVs9EZHJFeQLJCfoxobWZw8WEVUioxOsvn37YuXKlTh+/HiRdceOHcNXX32Ffv36VSg4IiJTuhavglYDuNeSwsObd5ogospj9CU0CxcuxM6dO9GxY0c888wzaNGiBQDg9OnT+O233+Dt7Y2FCxeaLFAioooqHOBej/NfEVElMzrB8vf3x5EjRzBz5kxs3boVv/zyCwDAzc0No0aNwvvvvw9/f3+TBUpEVFH/DXDn+CsiqlwVmgTGz88Pa9euhRACt2/fBgDUqlULEgkvfSYiyyKEQNLpwgHu7MEiosplkln2JBIJFAoFXFxcmFwRkUVKv6VF5l0tpDIgoAkTLCKqXBW6jfyRI0fQt29fODk5wcvLC/v27QMA3LlzBwMHDsTevXtNESMRUYVduT89g1+QHewd+EOQiCqX0QnWwYMH0bVrV1y8eBHPP/88tFqtfl3NmjWRkZGBlStXmiRIIqKK4g2eiagqGZ1gvf3222jWrBnOnj2L999/v8j6nj174tChQxUKjojIVPRXEHKAOxFVAaMTrH///Rfjxo2DQqEodtxV7dq1kZKSUqHgiIhMQaMWuB7PAe5EVHWMTrDkcrnBacGH3bhxAy4uLsZWT0RkMtfjVVAVAE5uEtQK4ASjRFT5jE6wHn/8cfz000/FrsvJycGaNWvQvXt3owMjIjKVhBO63qsGre15pTMRVQmjE6z58+fjyJEj6N+/P3bs2AEAOHHiBL755hu0a9cOt2/fxuzZs00WKBGRsS6f0A1wbxDM8VdEVDWMngcrJCQE27dvx8SJEzF69GgAwBtvvAEACAoKwvbt29G6dWvTRElEZCStViDxZGGCxfFXRFQ1KjTR6JNPPon4+HgcP34cly5dglarRVBQENq1a8dueCKyCKlJauRmCdg7SFCnMRMsIqoaJpnJvW3btmjbtq0pqiIiMqnLJ/67elBmxx9+RFQ1KpRgKZVKfP3119i+fTuSkpIAAPXr18dTTz2F8ePHw8HBwRQxEhEZLSGO46+IqOoZPcj9+vXraNOmDV577TWcOHECtWrVQq1atXDixAm89tpraNOmDa5fv27KWImIykUIgcv3x18FteHpQSKqOkYnWJMnT8aVK1fw448/4saNG9i3bx/27duHGzduYOPGjbh69SomT55syliJiMrlXrIGGbe1kNkB9ZqzB4uIqo7RpwhjYmIwbdo0DB48uMi6IUOG4NixY/jss88qFBwRUUUUjr+q00TOGzwTUZUyugfL1dUV3t7eJa739fWFq6ursdUTEVXY5ZMcf0VE5mF0gjVu3DhERUUhNze3yLrs7GysWbMGL730UoWCIyKqCP0A99Ycf0VEVcvoU4Rt2rTBtm3b0LRpU4wZMwYNGzYEAFy8eBHr1q2Dp6cnWrdujc2bNxtsN2jQoIpFTERUBln3NLh9TQOJRHeLHCKiqmR0gjV8+HD9///v//6vyPrr169jxIgREELol0kkEmg0GmNfkoiozC6f1I2/8m1gByc3ozvriYiMYnSC9eeff5oyDiIik9Lff5C9V0RkBkYnWN27dzdlHEREJvXfDZ45/oqIqp7R/eanTp0qtcxPP/1kbPVEREbLz9HixiU1AF5BSETmYXSC1b59e0RGRkKr1RZZd+/ePQwbNgzDhg0zOrDly5ejfv36cHBwQEhICA4fPlxi2aioKEgkEoPHw7fpEUJgzpw58PPzg6OjI0JDQ3Hx4kWj4yMiy5V4UgWhBbz8ZfCoJTN3OERUDRmdYI0ZMwbvvPMOOnfujPj4eP3yLVu2oEWLFti2bRuWLl1qVN0bN25EREQE5s6di2PHjiE4OBhhYWG4detWidu4ubkhOTlZ/7hy5YrB+kWLFuHTTz/FihUrcOjQITg7OyMsLAz5+flGxUhEluvCESUAoGFb9l4RkXkYnWB99dVX2LFjB65fv462bdviww8/xPPPP49BgwYhKCgIcXFxePXVV42qe/HixZgwYQLGjRuH5s2bY8WKFXBycsLq1atL3EYikcDX11f/8PHx0a8TQmDp0qV49913MXDgQLRu3Rrr1q3DzZs3sWXLFqNiJCLLdeGIbvxV4w5MsIjIPIwe5A4AYWFhOHPmDMLCwvD2228DAN555x0sWLAAEolxt6UoKCjA0aNHMWvWLP0yqVSK0NBQxMbGlrhddnY26tWrB61Wi8ceewzvv/8+WrRoAQBITExESkoKQkND9eXd3d0REhKC2NhYgyknCimVSiiVSv3zzMxMAIBKpYJKpTKqbQ8rrMdU9VkCtsk62HKb0m4pcTNBN/4qMFhqtW205X3ENlm2ymiTLb0/ZVWhBCsnJwczZszA4cOHERwcjIsXL2L16tXo1KkTnnrqKaPqvHPnDjQajUEPFAD4+Pjg/PnzxW7TpEkTrF69Gq1bt0ZGRgY+/vhjdO7cGWfOnEGdOnWQkpKir+PhOgvXPSwyMhLz588vsnz37t1wcnIypmklio6ONml9loBtsg622KYt6+IANISLdw72Hzxk7nAqzBb3EdtkHUzZpuLu+mLrKjQP1ksvvYSbN28iMjISb775JhISEjB27FgMGDAA48aNw5IlS6rkfoSdOnVCp06d9M87d+6MZs2aYeXKlVi4cKFRdc6aNQsRERH655mZmQgICECfPn3g5uZW4ZgBXUYfHR2N3r17Qy63jUvJ2SbrYMttcihoBkCF9k96Gf1DzxLY8j5imyxbZbSp8CxQdWJ0ghUaGoo2BCMXNQAAJ7JJREFUbdrgt99+05+Ka9SoEQ4cOIBPPvkEc+bMwZ49e5CUlFSuemvWrAmZTIbU1FSD5ampqfD19S1THXK5HG3btsWlS5cAQL9damoq/Pz8DOps06ZNsXUoFAooFIpi6zb1l6gy6jQ3tsk62FqbhAASjutODzYNcbSJttnaPgLYJmthyjbZ2ntTFkYPcp89ezYOHTqkT64KSSQSTJ8+HUePHi1ySq4s7O3t0a5dO8TExOiXabVaxMTEGPRSPYpGo8GpU6f0yVRgYCB8fX0N6szMzMShQ4fKXCcRWb7cu47IvCMgt+cM7kRkXkb3YM2bN++R65s1a/bIQemPEhERgTFjxqB9+/bo2LEjli5dipycHIwbNw4AMHr0aNSuXRuRkZEAgAULFuDxxx9Hw4YNkZ6ejo8++ghXrlzB+PHjAeiSvqlTp+K9995Do0aNEBgYiNmzZ8Pf3x/h4eFGxUhEliftiu70fWCwPeQK4y60ISIyhXIlWIcPH0bDhg3h6elZatnExET89ddfGD16dLmDGjZsGG7fvo05c+YgJSUFbdq0wc6dO/U9YlevXoVU+l/nW1paGiZMmICUlBTUqFED7dq1w8GDB9G8eXN9mRkzZiAnJwcvv/wy0tPT0bVrV+zcubPIhKREZL3uJbkDAJp0KHp6n4ioKpXrFGGnTp2wc+dO/fN79+7ByckJ+/btK1L24MGD+h4nY0yZMgVXrlyBUqnEoUOHEBISol+3d+9eREVF6Z8vWbJEXzYlJQXbtm1D27ZtDeqTSCRYsGABUlJSkJ+fjz179qBx48ZGx0dElkWtEki/puvBasL5r4jIzMqVYAkhijzPz8+HRqMxaVBEROV19awaWpUMzh4S+AVVaAYaIqIKM3qQOxGRJbl4VDeRYaPH5JBKOf6KiMyLCRYR2QR9gtW++l0OTkSWhwkWEVm9vCwtrp3XzX/FBIuILEG5ByokJSXh2LFjAICMjAwAwMWLF+Hh4WFQLjExseLRERGVwcVjBRBawMkzDx61vMwdDhFR+ROs2bNnY/bs2QbLJk2aVKScEMLoGz4TEZXHuX90N2avUS8DQB3zBkNEhHImWGvWrKmsOIiIjKLVCpw5qEuwvILSzRsMEdF95UqwxowZU1lxEBEZ5epZFbLuauHgLIFH3ep3Q1kiskwc5E5EVu30AV3vVZOOckhlopTSRERVgwkWEVm10wfyAQDNu3D2diKyHEywiMhq3b6mRmqSBlIZ0DSE0zMQkeVggkVEVuv0X7rTgw0fs4ejCw9nRGQ5eEQiIqt16i/d6cFWXRVmjoSIyBATLCKySllpGiSd1t0ep0VXBzNHQ0RkiAkWEVmls38rIQRQp7EdavjIzB0OEZEBJlhEZJUKp2do2Y29V0RkeZhgEZHVKcgXiP/3foLF8VdEZIGYYBGR1Yn/VwmVEqjhK4V/w3LfUpWIqNIxwSIiq1M4PUPLrg68qTwRWSQmWERkVVRKgZP7ddMztH6CpweJyDIxwSIiq3I2Von8bAEPbykatOHtcYjIMjHBIiKrcmRXHgDgsd6OkEp5epCILBMTLCKyGjkZWpyL1Y2/ah/G6RmIyHIxwSIiqxH3Rz40aqB2Izv4NeDNnYnIcjHBIiKrUXh6sH2Yo5kjISJ6NCZYRGQVbl9XI+m0ChIp0DaUpweJyLIxwSIiq3D0fu9V4/b2cK/Jew8SkWVjgkVEFk8IgaO7dXNf8fQgEVkDJlhEZPGunFHhzg0N7B0kaNWNk4sSkeVjgkVEFu/ITt3pwVbdFVA48bBFRJaPRyoismgqpcDxP3h6kIisCxMsIrJox2PykJupuzVOo8d4axwisg5MsIjIYgkhsP+nXABA10FOkNnx1jhEZB2YYBGRxUo8pcKNC2rI7YHHBziZOxwiojJjgkVEFuuv+71Xj/VxhLM7D1dEZD14xCIii5R+S4OT+3SD27s9x94rIrIuFptgLV++HPXr14eDgwNCQkJw+PDhEst+/fXX6NatG2rUqIEaNWogNDS0SPmxY8dCIpEYPPr27VvZzSAiIx3ckgutBghqI0ftRryxMxFZF4tMsDZu3IiIiAjMnTsXx44dQ3BwMMLCwnDr1q1iy+/duxcjRozAn3/+idjYWAQEBKBPnz64ceOGQbm+ffsiOTlZ//jhhx+qojlEVE4qpUDsr7q5r7oNdjZzNERE5WeRCdbixYsxYcIEjBs3Ds2bN8eKFSvg5OSE1atXF1v++++/x6RJk9CmTRs0bdoU33zzDbRaLWJiYgzKKRQK+Pr66h81atSoiuYQUTkd/yMf2elaeHhL0bIrZ24nIutjcQlWQUEBjh49itDQUP0yqVSK0NBQxMbGlqmO3NxcqFQqeHp6Gizfu3cvvL290aRJE0ycOBF37941aexEVHFCCPz1Uw4AoMuznJqBiKyTnbkDeNidO3eg0Wjg4+NjsNzHxwfnz58vUx1vvfUW/P39DZK0vn37YtCgQQgMDERCQgLefvtt9OvXD7GxsZDJZEXqUCqVUCqV+ueZmZkAAJVKBZVKZUzTiiisx1T1WQK2yTpYcpsS4lS4Hq+GnRxo309e5hgtuU3GsLX2AGyTtaiMNtnS+1NWEiGEMHcQD7p58yZq166NgwcPolOnTvrlM2bMwL59+3Do0KFHbv/BBx9g0aJF2Lt3L1q3bl1iucuXLyMoKAh79uxBr169iqyfN28e5s+fX2T5+vXr4eTEK5qIKoMQQNyGZsi47gb/Nqlo3DvJ3CERkQnk5uZi5MiRyMjIgJubm7nDqRIW14NVs2ZNyGQypKamGixPTU2Fr6/vI7f9+OOP8cEHH2DPnj2PTK4AoEGDBqhZsyYuXbpUbII1a9YsRERE6J9nZmbqB8+b6sOhUqkQHR2N3r17Qy63jauk2CbrYKltunCkAPuuZ8FODox7uwncazUv87aW2iZj2Vp7ALbJWlRGmwrPAlUnFpdg2dvbo127doiJiUF4eDgA6AesT5kypcTtFi1ahP/7v//Drl270L59+1Jf5/r167h79y78/PyKXa9QKKBQFB1cK5fLTf4lqow6zY1tsg6W1CYhBKLX6A7CncOdUNPfwah6LKlNpmBr7QHYJmthyjbZ2ntTFhY3yB0AIiIi8PXXX2Pt2rU4d+4cJk6ciJycHIwbNw4AMHr0aMyaNUtf/sMPP8Ts2bOxevVq1K9fHykpKUhJSUF2djYAIDs7G2+++Sb++ecfJCUlISYmBgMHDkTDhg0RFhZmljYSkaGzsUpcOauCXAH0ep5TMxCRdbO4HiwAGDZsGG7fvo05c+YgJSUFbdq0wc6dO/UD369evQqp9L/c8Msvv0RBQQEGDx5sUM/cuXMxb948yGQynDx5EmvXrkV6ejr8/f3Rp08fLFy4sNheKiKqWkII7PxG94Oo63POcPMqeuEJEZE1scgECwCmTJlS4inBvXv3GjxPSkp6ZF2Ojo7YtWuXiSIjIlM7/ZcS1y+ooXCU4MmR7L0iIutnkacIiaj60GoFdqzS9V49McQJLh48LBGR9eORjIjM6viefCQnqOHgIkGP4ey9IiLbwASLiMwmL1uLX5dnAQCeHOEMJzcekojINvBoRkRms+ObbGTe1aJWHRl6jmDvFRHZDiZYRGQW1+JVOLA5FwDw3BtusLPnPQeJyHYwwSKiKqfVCPz0cSaEFngs1AFNOnC6FCKyLUywiKjKHdyah6vnVHBwlmDgq67mDoeIyOSYYBFRlcq8q8G2r3QD2/u/7MJJRYnIJjHBIqIqI4TAz4szkZ8tENDUDp3DncwdEhFRpWCCRURV5uCWPJzcp4TMDhjypjukMg5sJyLbxASLiKrEjYsqbPksEwDw9ERXBDSRmzkiIqLKwwSLiCpdfq4Wa+ekQ10ANO+sQPehPDVIRLaNCRYRVSohdFMy3L6mgYe3FCPfcYdEwlODRGTbmGARUaU6vD0PR3fnQyoDXpjrAWd3HnaIyPbxSEdElebSMSU2fawbd9VvvAsaBNubOSIioqrBBIuIKsXNSyqsmpUOjQpo9YQCT47ivQaJqPpggkVEJpeWosFX09OQnyPQIFiOF+Z6QCrluCsiqj6YYBGRSeVkaLHijXvIuKOFb6AdXoqsAbmCyRURVS9MsIjIZPJztPjmrTTcuqK7YvCVT2rAyY2HGSKqfuzMHQAR2YasexqsnJ6GGxfUcHSR4OWPa8DDm/cZJKLqiQkWEVXY3ZtqrIhIw53rGrjU0PVc+TXgTO1EVH0xwSKiCrmZoMLKiDRk3tXC00+G/y2ugVoBPLQQUfXGoyARGe3cP0p8Oy8dedkCfg3s8MriGnCvydOCRERMsIio3DRqgZ2rsrHn2xwAQP1Wckz4kAPaiYgKMcEionLJuKPBt/PSkRCnAgB0edYJA6e4cioGIqIHMMEiojI7fSAfGz/IRHa6FgonCYa95Ya2vRzNHRYRkcVhgkVEpUpL1WDz0kyc/ksJAPAPssOYhR7wrstDCBFRcXh0JKISadQCf/2cix3fZKMgT0AqA3oMd0bYiy6w5ylBIqISMcEioiK0WoGTe5XYuTobqUlqALqB7EPfdOP8VkREZcAEi4j0hBA4tV+XWCUn6BIrJ1cJnp7oipCnHXnDZiKiMmKCRURQ5mlxLDofB37Oxc37iZWDswTdhzmj+1AnOLpw+gUiovJggkVUjd2+psGh3/NweHse8rMFAEDhKMETQ5zQY7gz57UiIjISEyyiaib9lgZHo/NwdEsL7E1O1y/38pehy7NO6NjfEc5MrIiIKoQJFpGNE0IgOUGNc4eUOPO3EoknVffXuEAiBZqGKNB1kBOahthzjBURkYkwwSKyMUII3L2pQeIpFRKOF+D8ISUy7mgNygS2toNdrUsYPqktPH0UZoqUiMh2McEisnLZ6VrcuKjCjYtqXDlbgMRTKmTdNUyo5AqgUTsFmnS0R6tuDnDx1GL79lS4evJUIBFRZbDYBGv58uX46KOPkJKSguDgYHz22Wfo2LFjieU3bdqE2bNnIykpCY0aNcKHH36Ip556Sr9eCIG5c+fi66+/Rnp6Orp06YIvv/wSjRo1qormEFWIEALZaVrcuqrBratq3LqiRupVDZITVEi/pS1SXmYH1GksR2BrOZqGKNCgtb3BvQJVqqLbEBGR6VhkgrVx40ZERERgxYoVCAkJwdKlSxEWFob4+Hh4e3sXKX/w4EGMGDECkZGRePrpp7F+/XqEh4fj2LFjaNmyJQBg0aJF+PTTT7F27VoEBgZi9uzZCAsLw9mzZ+Hg4FDVTSTSE0IgL0sg654WGXc0yLijRcZtDTJua3EvRYO7NzVIS9GgIF+UWEfNOjLUbiRHncZ2CGxtj4Cmcs60TkRkRhaZYC1evBgTJkzAuHHjAAArVqzAtm3bsHr1asycObNI+WXLlqFv37548803AQALFy5EdHQ0Pv/8c6xYsQJCCCxduhTvvvsuBg4cCABYt24dfHx8sGXLFgwfPrzqGkc2RwgBVQFQkCugzNNCmSegzBXIzxHIz9EiL1v3/7wsLXKztMjNFMjN1CInQ4vsNC2y07XQqEt/HYkEqOErg089GWrVtYNPXTv4BtrBv5EdHJx4qo+I6P/bu//gmO88juOvTeQHQRCSCOLXKb0WdX5kogxHKpy7Cj3UOfSupz3kzo8z1d4cyt2MXrWdTo1x2kPaKVrmiraKRkiu50L9uiuuDBqck0RFI5E0ssl+7o80Wyu7+aHf2N3k+ZjZ2Xw/+/l+8nnvZ7+bV7672fgSnwtYpaWlOnr0qJ577jlnW0BAgBISEpSZmel2n8zMTC1YsMClLTExUdu3b5ckZWVlKScnRwkJCc7bw8PDFRcXp8zMTK8FrK9yyvV1fojyrpSrSZO7P9tgPJ/Y+KZDHfvf3se438fc1mDMt/3s9jLdvNpMV86VqUmTittuH8tUXhvzzfW3Y1SOYyQZR0VjZbvz4qi8Ni7bjvKKMY1DKi+vuN3h+KbdUfGvXxzlkqOs4uvyMslRXnFdXl7xP/ccZRXX5WVSmd2ozG5UbpfstxzKzb1fX3x4Q2V2qazUyH7LqPSWkb1Est8ytbpPaxLa3KbwtoEKbxug8HYBCm8bqDbtv720jgxUk2DOSgGAP/C5gHXt2jWVl5crKirKpT0qKkqnT592u09OTo7b/jk5Oc7bK9s89bnTrVu3dOvWLed2QUGBJMlut8tut7vdp65Wzb6hm189pENv5Fsynu/orSNv3vD2JCzWUjdU82mmoNCKD+oMDrUpNKziEhJmU9Mwm5o2D1DTljY1a2FTs5YBatbSpuatA9S8lU1hrQIUVG14MjIqk0UPPedj2KrHsi9oaDU1tHokavIX9VFTQ7p/asvnApavWLFihZYtW1al/eOPP1azZs0s+R5ljr4KDKrFP869q5MWd5xSsVW76eF7uB/Ddsf2nf1tt7dX7mMzNbbZJMlmbvu6YkybraK9clxbQGWfb64r96nsF1DRt6Lft19XtBvZAm7b/uYSEGhkC3BUbAdWbAcEOr79uolDAYGOiusmFbcFBlVsBwaVKyCoYttWw1qVSSqQVGCXlPfNxYtSU1O9O4F60NBqamj1SNTkL6ysqbi42LKx/IXPBay2bdsqMDBQubm5Lu25ubmKjo52u090dHS1/Suvc3Nz1b59e5c+Dz30kNsxn3vuOZeXHQsKCtSpUyeNGjVKLVu2rHNd7jzyiF2pqal65JFHFFSboOUH7HZq8gfU5PsaWj0SNfmL+qip8lWgxsTnAlZwcLD69++vtLQ0JSUlSZIcDofS0tKUnJzsdp/4+HilpaVp3rx5zrbU1FTFx8dLkrp27aro6GilpaU5A1VBQYEOHTqkWbNmuR0zJCREISFVP4AxKCjI8oOoPsb0NmryD9Tk+xpaPRI1+Qsra2po901t+FzAkqQFCxZoxowZGjBggAYNGqRXX31VRUVFzr8qnD59ujp06KAVK1ZIkubOnathw4bp5Zdf1tixY/XOO+/oyJEjev311yVJNptN8+bN05/+9Cf16NHD+TENMTExzhAHAABgFZ8MWJMnT9aXX36pJUuWKCcnRw899JB2797tfJP6pUuXFBDw7Z+lDx48WJs2bdIf/vAH/f73v1ePHj20fft252dgSdIzzzyjoqIiPfXUU8rPz9eQIUO0e/duPgMLAABYzicDliQlJyd7fEkwPT29StvEiRM1ceJEj+PZbDYtX75cy5cvt2qKAAAAbvHphAAAABYjYAEAAFiMgAUAAGAxAhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxQhYAAAAFiNgAQAAWIyABQAAYDECFgAAgMV89p89+xpjjCSpoKDAsjHtdruKi4tVUFCgoKAgy8b1JmryD9Tk+xpaPRI1+Yv6qKnyZ2flz9LGgIBVS4WFhZKkTp06eXkmAAD4p8LCQoWHh3t7GveEzTSmOPkdOBwOXblyRS1atJDNZrNkzIKCAnXq1En//e9/1bJlS0vG9DZq8g/U5PsaWj0SNfmL+qjJGKPCwkLFxMQoIKBxvDuJM1i1FBAQoI4dO9bL2C1btmwwB2YlavIP1OT7Glo9EjX5C6traixnrio1jhgJAABwDxGwAAAALEbA8qKQkBAtXbpUISEh3p6KZajJP1CT72to9UjU5C8aYk3ewJvcAQAALMYZLAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBKx6tnr1anXp0kWhoaGKi4vTp59+Wm3/rVu3qlevXgoNDVXv3r310Ucf3aOZ1mzFihUaOHCgWrRoocjISCUlJenMmTPV7pOSkiKbzeZyCQ0NvUczrtnzzz9fZX69evWqdh9fXiNJ6tKlS5WabDab5syZ47a/L67R3//+d/3kJz9RTEyMbDabtm/f7nK7MUZLlixR+/bt1bRpUyUkJOjs2bM1jlvX49FK1dVkt9u1aNEi9e7dW2FhYYqJidH06dN15cqVase8m8evVWpaoyeeeKLK3EaPHl3juL66RpLcHlc2m00rV670OKY310iq3fN2SUmJ5syZo4iICDVv3lyPPfaYcnNzqx33bo/BxoSAVY/effddLViwQEuXLtWxY8fUt29fJSYm6urVq277//Of/9SUKVP05JNP6vjx40pKSlJSUpJOnjx5j2fuXkZGhubMmaODBw8qNTVVdrtdo0aNUlFRUbX7tWzZUtnZ2c7LxYsX79GMa+eBBx5wmd8//vEPj319fY0k6fDhwy71pKamSpImTpzocR9fW6OioiL17dtXq1evdnv7iy++qNdee01/+ctfdOjQIYWFhSkxMVElJSUex6zr8Wi16moqLi7WsWPHtHjxYh07dkzvvfeezpw5o0cffbTGcevy+LVSTWskSaNHj3aZ2+bNm6sd05fXSJJLLdnZ2Vq/fr1sNpsee+yxasf11hpJtXvenj9/vj744ANt3bpVGRkZunLliiZMmFDtuHdzDDY6BvVm0KBBZs6cOc7t8vJyExMTY1asWOG2/6RJk8zYsWNd2uLi4szTTz9dr/O8W1evXjWSTEZGhsc+GzZsMOHh4fduUnW0dOlS07dv31r397c1MsaYuXPnmu7duxuHw+H2dl9fI0lm27Ztzm2Hw2Gio6PNypUrnW35+fkmJCTEbN682eM4dT0e69OdNbnz6aefGknm4sWLHvvU9fFbX9zVM2PGDDNu3Lg6jeNvazRu3DgzYsSIavv4yhpVuvN5Oz8/3wQFBZmtW7c6+3z++edGksnMzHQ7xt0eg40NZ7DqSWlpqY4ePaqEhARnW0BAgBISEpSZmel2n8zMTJf+kpSYmOixv7fduHFDktSmTZtq+928eVOdO3dWp06dNG7cOJ06depeTK/Wzp49q5iYGHXr1k1Tp07VpUuXPPb1tzUqLS3V22+/rV/+8pfV/pNyX1+j22VlZSknJ8dlHcLDwxUXF+dxHe7mePS2GzduyGazqVWrVtX2q8vj915LT09XZGSkevbsqVmzZikvL89jX39bo9zcXO3cuVNPPvlkjX19aY3ufN4+evSo7Ha7y/3eq1cvxcbGerzf7+YYbIwIWPXk2rVrKi8vV1RUlEt7VFSUcnJy3O6Tk5NTp/7e5HA4NG/ePD388MN68MEHPfbr2bOn1q9frx07dujtt9+Ww+HQ4MGDdfny5Xs4W8/i4uKUkpKi3bt3a82aNcrKytLQoUNVWFjotr8/rZEkbd++Xfn5+XriiSc89vH1NbpT5X1dl3W4m+PRm0pKSrRo0SJNmTKl2n+2W9fH7700evRovfXWW0pLS9Of//xnZWRkaMyYMSovL3fb39/W6M0331SLFi1qfCnNl9bI3fN2Tk6OgoODqwT5mn5WVfap7T6NURNvTwD+ac6cOTp58mSN7yWIj49XfHy8c3vw4MG6//77tXbtWv3xj3+s72nWaMyYMc6v+/Tpo7i4OHXu3Flbtmyp1W+mvm7dunUaM2aMYmJiPPbx9TVqbOx2uyZNmiRjjNasWVNtX19+/D7++OPOr3v37q0+ffqoe/fuSk9P18iRI704M2usX79eU6dOrfEPQnxpjWr7vA1rcAarnrRt21aBgYFV/hIjNzdX0dHRbveJjo6uU39vSU5O1ocffqj9+/erY8eOddo3KChI/fr107lz5+ppdt9Nq1atdN9993mcn7+skSRdvHhRe/fu1a9+9as67efra1R5X9dlHe7mePSGynB18eJFpaamVnv2yp2aHr/e1K1bN7Vt29bj3PxljSTpk08+0ZkzZ+p8bEneWyNPz9vR0dEqLS1Vfn6+S/+aflZV9qntPo0RAaueBAcHq3///kpLS3O2ORwOpaWluZwtuF18fLxLf0lKTU312P9eM8YoOTlZ27Zt0759+9S1a9c6j1FeXq4TJ06offv29TDD7+7mzZs6f/68x/n5+hrdbsOGDYqMjNTYsWPrtJ+vr1HXrl0VHR3tsg4FBQU6dOiQx3W4m+PxXqsMV2fPntXevXsVERFR5zFqevx60+XLl5WXl+dxbv6wRpXWrVun/v37q2/fvnXe916vUU3P2/3791dQUJDL/X7mzBldunTJ4/1+N8dgo+TlN9k3aO+8844JCQkxKSkp5j//+Y956qmnTKtWrUxOTo4xxphp06aZZ5991tn/wIEDpkmTJuall14yn3/+uVm6dKkJCgoyJ06c8FYJLmbNmmXCw8NNenq6yc7Odl6Ki4udfe6sadmyZWbPnj3m/Pnz5ujRo+bxxx83oaGh5tSpU94ooYrf/e53Jj093WRlZZkDBw6YhIQE07ZtW3P16lVjjP+tUaXy8nITGxtrFi1aVOU2f1ijwsJCc/z4cXP8+HEjybzyyivm+PHjzr+oe+GFF0yrVq3Mjh07zGeffWbGjRtnunbtar7++mvnGCNGjDCrVq1ybtd0PHqzptLSUvPoo4+ajh07mn/9618ux9etW7c81lTT49db9RQWFpqFCxeazMxMk5WVZfbu3Wt+8IMfmB49epiSkhKP9fjyGlW6ceOGadasmVmzZo3bMXxpjYyp3fP2r3/9axMbG2v27dtnjhw5YuLj4018fLzLOD179jTvvfeec7s2x2BjR8CqZ6tWrTKxsbEmODjYDBo0yBw8eNB527Bhw8yMGTNc+m/ZssXcd999Jjg42DzwwANm586d93jGnklye9mwYYOzz501zZs3z1l/VFSU+dGPfmSOHTt27yfvweTJk0379u1NcHCw6dChg5k8ebI5d+6c83Z/W6NKe/bsMZLMmTNnqtzmD2u0f/9+t4+1ynk7HA6zePFiExUVZUJCQszIkSOr1Nq5c2ezdOlSl7bqjsf6Vl1NWVlZHo+v/fv3e6yppsevt+opLi42o0aNMu3atTNBQUGmc+fOZubMmVWCkj+tUaW1a9eapk2bmvz8fLdj+NIaGVO75+2vv/7azJ4927Ru3do0a9bMjB8/3mRnZ1cZ5/Z9anMMNnY2Y4ypn3NjAAAAjRPvwQIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAlBvUlJSZLPZPF4OHjzo7SkCQL1o4u0JAGj4li9f7vafg3/ve9/zwmwAoP4RsADUuzFjxmjAgAFenUNRUZHCwsK8OgcAjQcvEQLwqgsXLshms+mll17S66+/ru7duyskJEQDBw7U4cOHq/Q/ffq0fvrTn6pNmzYKDQ3VgAED9P7777v0qXxpMiMjQ7Nnz1ZkZKQ6duzovH316tXq1q2bmjZtqkGDBumTTz7R8OHDNXz4cEnSzZs3FRYWprlz51b5/pcvX1ZgYKBWrFhh7R0BoEHhDBaAenfjxg1du3bNpc1msykiIsK5vWnTJhUWFurpp5+WzWbTiy++qAkTJuiLL75QUFCQJOnUqVN6+OGH1aFDBz377LMKCwvTli1blJSUpL/97W8aP368y/eYPXu22rVrpyVLlqioqEiStGbNGiUnJ2vo0KGaP3++Lly4oKSkJLVu3doZwpo3b67x48fr3Xff1SuvvKLAwEDnmJs3b5YxRlOnTq2X+wpAA2EAoJ5s2LDBSHJ7CQkJMcYYk5WVZSSZiIgIc/36dee+O3bsMJLMBx984GwbOXKk6d27tykpKXG2ORwOM3jwYNOjR48q33fIkCGmrKzM2X7r1i0TERFhBg4caOx2u7M9JSXFSDLDhg1ztu3Zs8dIMrt27XKpqU+fPi79AMAdXiIEUO9Wr16t1NRUl8uuXbtc+kyePFmtW7d2bg8dOlSS9MUXX0iSrl+/rn379mnSpEkqLCzUtWvXdO3aNeXl5SkxMVFnz57V//73P5cxZ86c6XL26ciRI8rLy9PMmTPVpMm3J/CnTp3q8r0lKSEhQTExMdq4caOz7eTJk/rss8/085///DveIwAaOl4iBFDvBg0aVOOb3GNjY122KwPPV199JUk6d+6cjDFavHixFi9e7HaMq1evqkOHDs7tO/9y8eLFi5Kq/vVikyZN1KVLF5e2gIAATZ06VWvWrFFxcbGaNWumjRs3KjQ0VBMnTqy2FgAgYAHwCbefabqdMUaS5HA4JEkLFy5UYmKi2753BqemTZt+pzlNnz5dK1eu1Pbt2zVlyhRt2rRJP/7xjxUeHv6dxgXQ8BGwAPiFbt26SZKCgoKUkJBwV2N07txZUsXZsB/+8IfO9rKyMl24cEF9+vRx6f/ggw+qX79+2rhxozp27KhLly5p1apVd1kBgMaE92AB8AuRkZEaPny41q5dq+zs7Cq3f/nllzWOMWDAAEVEROiNN95QWVmZs33jxo3OlyLvNG3aNH388cd69dVXFRERoTFjxtx9EQAaDc5gAah3u3bt0unTp6u0Dx48WAEBtf89b/Xq1RoyZIh69+6tmTNnqlu3bsrNzVVmZqYuX76sf//739XuHxwcrOeff16/+c1vNGLECE2aNEkXLlxQSkqKunfvLpvNVmWfn/3sZ3rmmWe0bds2zZo1y/mREQBQHQIWgHq3ZMkSt+0bNmxwfrhnbXz/+9/XkSNHtGzZMqWkpCgvL0+RkZHq16+fx+9xp+TkZBlj9PLLL2vhwoXq27ev3n//ff32t79VaGholf5RUVEaNWqUPvroI02bNq3WcwXQuNlM5TtIAaCRcjgcateunSZMmKA33nijyu3jx4/XiRMndO7cOS/MDoA/4j1YABqVkpIS3fl75VtvvaXr16+7PZuWnZ2tnTt3cvYKQJ1wBgtAo5Kenq758+dr4sSJioiI0LFjx7Ru3Trdf//9Onr0qIKDgyVJWVlZOnDggP7617/q8OHDOn/+vKKjo708ewD+gvdgAWhUunTpok6dOum1117T9evX1aZNG02fPl0vvPCCM1xJUkZGhn7xi18oNjZWb775JuEKQJ1wBgsAAMBivAcLAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACw2P8BN/1SBEEvxc4AAAAASUVORK5CYII=",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -455,10 +447,10 @@
    "source": [
     "make_n_children_widget(\n",
     "    alpha=(1e-2, 1.0),\n",
-    "    scale=(1e-3, 1.0),\n",
+    "    scale=(1e-2, 1.0),\n",
     "    e0=(0, 10, False),\n",
     "    alpha_age=(1e-7, 1e-4),\n",
-    "    beta=(1e-5, 1e-3),\n",
+    "    beta=(1e-6, 1e-3),\n",
     "    energy_max=20,\n",
     "    hazard_cls=bd.ELGompertzHazard,\n",
     "    birth_scale=(1e-6, 1e-3),\n",
@@ -466,14 +458,6 @@
     "    birth_e0=(0, 10, False),\n",
     ")"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ae2e473a-2cb6-4827-a157-407395c4a039",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
diff --git a/src/emevo/analysis/log_plotting.py b/src/emevo/analysis/log_plotting.py
index 279431f4..05aa7dec 100644
--- a/src/emevo/analysis/log_plotting.py
+++ b/src/emevo/analysis/log_plotting.py
@@ -1,16 +1,17 @@
+from collections.abc import Iterable
 from os import PathLike
 from pathlib import Path
 
 import numpy as np
 import polars as pl
 import seaborn as sns
+from matplotlib import pyplot as plt
 from matplotlib.axes import Axes
 from matplotlib.collections import LineCollection
 from mpl_toolkits.mplot3d import Axes3D
 from mpl_toolkits.mplot3d.art3d import Line3DCollection
 
 from emevo.analysis import Tree
-from emevo.exp_utils import SavedPhysicsState
 
 
 def load_log(pathlike: PathLike, last_idx: int = 10) -> pl.LazyFrame:
@@ -67,30 +68,23 @@ def get_pos(ij: tuple[int, int]) -> tuple | None:
     return ax
 
 
-def plot_rewards(
+def plot_rewards_2d(
     ax: Axes,
-    reward_df: pl.DataFrame,
     tree_df: pl.DataFrame,
+    reward_df: pl.DataFrame,
     tree: Tree | None = None,
     reward_axis: str = "food",
 ) -> Axes:
-    tr = tree_df.join(reward_df, on="index")
+    tr = tree_df.join(reward_df, on="unique_id")
     labels = set(tree_df["label"])
     palette = sns.color_palette("husl", len(labels))
-    sns.scatterplot(
-        data=tr,
-        x="birth-step",
-        y=reward_axis,
-        hue="label",
-        palette=palette,
-        ax=ax,
-        legend=False,
-    )
+    colors = [palette[label] for label in tr["label"]]
+    ax.scatter(tr["birthtime"], tr[reward_axis], c=colors, s=5, marker="o")
     if tree != None:
 
         def get_pos(ij: tuple[int, int]) -> tuple | None:
-            stepi = tr.filter(pl.col("index") == ij[0])
-            stepj = tr.filter(pl.col("index") == ij[1])
+            stepi = tr.filter(pl.col("unique_id") == ij[0])
+            stepj = tr.filter(pl.col("unique_id") == ij[1])
             if len(stepi) != 1 or len(stepj) != 1:
                 return None
             return (
@@ -101,26 +95,66 @@ def get_pos(ij: tuple[int, int]) -> tuple | None:
         edge_collection = LineCollection(
             [e for e in map(get_pos, tree.all_edges()) if e is not None],
             colors="gray",
-            linewidths=0.5,
+            linewidths=0.2,
             antialiaseds=(1,),
-            alpha=0.6,
+            alpha=0.4,
         )
         ax.add_collection(edge_collection)
+
+    for label in labels:
+        tr_selected = tr.filter(pl.col(f"in-label-{label}") == True).to_pandas()
+        order = 2 if len(tr_selected) > 100 else 1
+        sns.regplot(
+            data=tr_selected,
+            x="birthtime",
+            y=reward_axis,
+            scatter=False,
+            color=palette[label],
+            order=order,
+            ax=ax,
+        )
+
     return ax
 
 
 def plot_lifehistory(
     ax: Axes,
-    phys_state: SavedPhysicsState,
-    slot: int,
-    start: int,
-    end: int,
+    logdir: Path,
+    log_indices: int | Iterable[int],
+    unique_id: int,
     xlim: float = 480.0,
     ylim: float = 360.0,
-) -> None:
-    assert start < end
-    axy = np.array(phys_state.circle_axy[start:end, slot])
-    x = axy[1]
-    y = axy[2]
-    ax.plot(x, y)
+    start_color: str = "blue",
+    end_color: str = "green",
+    food_color: str = "red",
+) -> Axes:
+    ax.set_xlim((0, xlim))
+    ax.set_ylim((0, ylim))
+    ax.axes.xaxis.set_visible(False)  # type: ignore
+    ax.axes.yaxis.set_visible(False)  # type: ignore
+    if isinstance(log_indices, int):
+        log = pl.scan_parquet(logdir / f"log-{log_indices}.parquet")
+        npzfile = np.load(logdir / f"state-{log_indices}.npz")
+        xy = npzfile["circle_axy"][:, :, 1:]
+    else:
+        parquet_list = []
+        xy_list = []
+        for i in log_indices:
+            parquet_list.append(pl.scan_parquet(logdir / f"log-{i}.parquet"))
+            xy_list.append(np.load(logdir / f"state-{i}.npz")["circle_axy"][:, :, 1:])
+        log = pl.concat(parquet_list)
+        xy = np.concatenate(xy_list)
+    indiv = log.filter(pl.col("unique_id") == unique_id).sort("step").collect()
+    slot = indiv["slots"][0]
+    offset = log.fetch(1)["step"][0]
+    start = indiv["step"][0] - offset + 1
+    end = indiv["step"][-1] - offset + 1
+    xy_indiv = xy[start:end, slot]
+    print(f"This agent lived {end - start + 1} steps in total from {start + offset}")
+    ax.plot(xy_indiv[:, 0], xy_indiv[:, 1])
+    ax.add_patch(plt.Circle(xy_indiv[0], radius=3.0, color=start_color, alpha=0.6))
+    ax.add_patch(plt.Circle(xy_indiv[-1], radius=3.0, color=end_color, alpha=0.6))
+    for xy in xy_indiv[indiv["got_food"][1:]]:
+        ax.add_patch(plt.Circle(xy, radius=1.0, color=food_color, alpha=0.8))
+    ax.set_title(f"Life history of {unique_id}")
     return ax

From 55e1c6687850ab5167fb654bfacf7ac708e32048 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 30 Jan 2024 18:10:41 +0900
Subject: [PATCH 228/337] [WIP] Multiple food sources

---
 src/emevo/environments/circle_foraging.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 0e079bfa..95d50195 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -5,7 +5,7 @@
 import warnings
 from collections.abc import Iterable
 from dataclasses import replace
-from typing import Any, Callable, Literal, NamedTuple
+from typing import Any, Callable, Literal, NamedTuple, Union
 
 import chex
 import jax
@@ -304,6 +304,10 @@ def _nonzero(arr: jax.Array, n: int) -> jax.Array:
     return jnp.cumsum(bincount)
 
 
+_MaybeLocatingFn = Union[LocatingFn, str, tuple[str, ...]]
+_MaybeNumFn = Union[ReprNumFn, str, tuple[str, ...]]
+
+
 class CircleForaging(Env):
     def __init__(
         self,
@@ -311,7 +315,7 @@ def __init__(
         n_max_agents: int = 100,
         n_max_foods: int = 40,
         food_num_fn: ReprNumFn | str | tuple[str, ...] = "constant",
-        food_loc_fn: LocatingFn | str | tuple[str, ...] = "gaussian",
+        food_loc_fn: _MaybeLocatingFn | list[_MaybeLocatingFn] = "gaussian",
         agent_loc_fn: LocatingFn | str | tuple[str, ...] = "uniform",
         xlim: tuple[float, float] = (0.0, 200.0),
         ylim: tuple[float, float] = (0.0, 200.0),

From 784a8ed343dd5c73990d8efba291e8a72c40c48f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 30 Jan 2024 18:36:13 +0900
Subject: [PATCH 229/337] Label

---
 src/emevo/environments/phyjax2d.py | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index fe341bb1..960ff503 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -213,6 +213,7 @@ class State(PyTreeOps):
     v: Velocity
     f: Force
     is_active: jax.Array
+    label: jax.Array
 
     @staticmethod
     def empty() -> Self:
@@ -221,16 +222,7 @@ def empty() -> Self:
             v=Velocity.zeros(0),
             f=Force.zeros(0),
             is_active=jnp.empty(0),
-        )
-
-    @staticmethod
-    def from_position(p: Position) -> Self:
-        n = p.batch_size()
-        return State(
-            p=p,
-            v=Velocity.zeros(n),
-            f=Force.zeros(n),
-            is_active=jnp.ones(n, dtype=bool),
+            label=jnp.zeros(0),
         )
 
     @staticmethod
@@ -240,6 +232,7 @@ def zeros(n: int) -> Self:
             v=Velocity.zeros(n),
             f=Force.zeros(n),
             is_active=jnp.ones(n, dtype=bool),
+            label=jnp.zeros(n, dtype=jnp.uint8),
         )
 
     def apply_force_global(self, point: jax.Array, force: jax.Array) -> Self:

From 89ca9e8e11742f6e086f6fce171c911e8738b098 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 30 Jan 2024 19:02:07 +0900
Subject: [PATCH 230/337] basic energy consumption

---
 src/emevo/environments/circle_foraging.py | 8 +++++++-
 src/emevo/exp_utils.py                    | 1 +
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 0e079bfa..5b47347a 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -334,6 +334,7 @@ def __init__(
         init_energy: float = 20.0,
         energy_capacity: float = 100.0,
         force_energy_consumption: float = 0.01 / 40.0,
+        basic_energy_consumption: float = 0.0,
         energy_share_ratio: float = 0.4,
         n_velocity_iter: int = 6,
         n_position_iter: int = 2,
@@ -366,6 +367,7 @@ def __init__(
         )
         # Energy
         self._force_energy_consumption = force_energy_consumption
+        self._basic_energy_consumption = basic_energy_consumption
         self._init_energy = init_energy
         self._energy_capacity = energy_capacity
         self._energy_share_ratio = energy_share_ratio
@@ -616,7 +618,11 @@ def step(
         sensor_obs = self._sensor_obs(stated=stated)
         # energy_delta = food - coef * |force|
         force_norm = jnp.sqrt(f1_raw**2 + f2_raw**2).ravel()
-        energy_delta = food_collision - self._force_energy_consumption * force_norm
+        energy_delta = (
+            food_collision
+            - self._force_energy_consumption * force_norm
+            - self._basic_energy_consumption
+        )
         # Remove and reproduce foods
         key, food_key = jax.random.split(state.key)
         stated, food_num, food_loc = self._remove_and_reproduce_foods(
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index ca1c5569..dd4e9228 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -57,6 +57,7 @@ class CfConfig:
     init_energy: float = 20.0
     energy_capacity: float = 100.0
     force_energy_consumption: float = 0.01 / 40.0
+    basic_energy_consumption: float = 0.0
     energy_share_ratio: float = 0.4
     n_velocity_iter: int = 6
     n_position_iter: int = 2

From 3103696e3c8755eb566f2339cfa83fa4f18ba321 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 30 Jan 2024 19:12:08 +0900
Subject: [PATCH 231/337] seasons-tri

---
 config/env/20240130-seasons-tri.toml | 39 ++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 config/env/20240130-seasons-tri.toml

diff --git a/config/env/20240130-seasons-tri.toml b/config/env/20240130-seasons-tri.toml
new file mode 100644
index 00000000..ad90c7b9
--- /dev/null
+++ b/config/env/20240130-seasons-tri.toml
@@ -0,0 +1,39 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["switching",
+       1000,
+       ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 90.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+   ],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 9b27403099ae897262a2d8a5747be5cd07562323 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 31 Jan 2024 17:14:58 +0900
Subject: [PATCH 232/337] seasons i200

---
 config/env/20240130-seasons-tri.toml  |  2 +-
 config/env/20240131-seasons-i200.toml | 40 +++++++++++++++++++++++++++
 2 files changed, 41 insertions(+), 1 deletion(-)
 create mode 100644 config/env/20240131-seasons-i200.toml

diff --git a/config/env/20240130-seasons-tri.toml b/config/env/20240130-seasons-tri.toml
index ad90c7b9..5929a12e 100644
--- a/config/env/20240130-seasons-tri.toml
+++ b/config/env/20240130-seasons-tri.toml
@@ -7,7 +7,7 @@ food_loc_fn = [
    1024000,
    ["gaussian", [360.0, 270.0], [48.0, 36.0]],
    ["switching",
-       1000,
+       200,
        ["gaussian", [360.0, 270.0], [48.0, 36.0]],
        ["gaussian", [240.0, 90.0], [48.0, 36.0]],
        ["gaussian", [120.0, 270.0], [48.0, 36.0]],
diff --git a/config/env/20240131-seasons-i200.toml b/config/env/20240131-seasons-i200.toml
new file mode 100644
index 00000000..f3ea337a
--- /dev/null
+++ b/config/env/20240131-seasons-i200.toml
@@ -0,0 +1,40 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["switching",
+       200,
+       ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+   ],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From c6ead4559f5b62b2d4e1ae5044b34b199f5f4fe3 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 1 Feb 2024 13:49:48 +0900
Subject: [PATCH 233/337] Increase the max scan size of qt widget

---
 src/emevo/analysis/qt_widget.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index 68a0f9df..ff579ee5 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -52,7 +52,7 @@ def _mgl_qsurface_fmt() -> QSurfaceFormat:
     return fmt
 
 
-N_MAX_SCAN: int = 4096
+N_MAX_SCAN: int = 10240
 N_MAX_CACHED_LOG: int = 200
 
 

From 03fbdb834c84f5d3f5d0b5933e542a337d59d072 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 1 Feb 2024 22:05:18 +0900
Subject: [PATCH 234/337] [widget] Food reward

---
 experiments/cf_asexual_evo.py   |  2 ++
 src/emevo/analysis/qt_widget.py | 43 +++++++++++++++++++++++++++++++--
 2 files changed, 43 insertions(+), 2 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index d83415aa..d2c6db1c 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -551,6 +551,7 @@ def widget(
     cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
     log_offset: int = 0,
     log_path: Optional[Path] = None,
+    self_terminate: bool = False,
     profile_and_rewards_path: Optional[Path] = None,
     env_override: str = "",
 ) -> None:
@@ -591,6 +592,7 @@ def widget(
         end=end,
         log_ds=log_ds,
         step_offset=step_offset,
+        self_terminate=self_terminate,
         profile_and_rewards=profile_and_rewards,
     )
 
diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index ff579ee5..f48eb013 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -155,6 +155,9 @@ def paintGL(self) -> None:
         self._ctx.clear(1.0, 1.0, 1.0)
         self._renderer.render(stated, circle_colors=circle_colors)  # type: ignore
 
+    def exitable(self) -> bool:
+        return self._end_index - 1 <= self._index
+
     def mousePressEvent(self, evt: QMouseEvent) -> None:  # type: ignore
         position = self._scale_position(evt.position())
         circle = self._get_stated(self._index).circle
@@ -279,6 +282,7 @@ class CBarState(enum.Enum):
     AGE = 1
     ENERGY = 2
     N_CHILDREN = 3
+    FOOD_REWARD = 4
 
 
 class CFEnvReplayWidget(QtWidgets.QWidget):
@@ -292,6 +296,7 @@ def __init__(
         env: CircleForaging,
         saved_physics: SavedPhysicsState,
         start: int = 0,
+        self_terminate: bool = False,
         end: int | None = None,
         step_offset: int = 0,
         log_ds: ds.Dataset | None = None,
@@ -300,6 +305,7 @@ def __init__(
         super().__init__()
 
         timer = QTimer()
+        timer.timeout.connect(self._check_exit)
         # Environment
         self._mgl_widget = MglWidget(
             timer=timer,
@@ -334,18 +340,21 @@ def __init__(
         radiobutton_1 = QtWidgets.QRadioButton("Age")
         radiobutton_2 = QtWidgets.QRadioButton("Energy")
         radiobutton_3 = QtWidgets.QRadioButton("Num. Children")
+        radiobutton_4 = QtWidgets.QRadioButton("Food Reward")
         radiobutton_1.setChecked(True)
         radiobutton_1.toggled.connect(self.cbarAge)
         radiobutton_2.toggled.connect(self.cbarEnergy)
         radiobutton_3.toggled.connect(self.cbarNChildren)
+        radiobutton_4.toggled.connect(self.cbarFood)
         self._cbar_state = CBarState.AGE
-        self._cbar_renderer = CBarRenderer(xlim * 2, ylim // 4)
+        self._cbar_renderer = CBarRenderer(int(xlim * 2), int(ylim * 0.4))
         self._showing_energy = True
         self._cbar_changed = True
         self._cbar_canvas = FigureCanvasQTAgg(self._cbar_renderer._fig)
         self._value_cm = mpl.colormaps["YlOrRd"]
         self._energy_cm = mpl.colormaps["YlGnBu"]
         self._n_children_cm = mpl.colormaps["PuBuGn"]
+        self._food_cm = mpl.colormaps["YlOrRd"]
         self._norm = mc.Normalize(vmin=0.0, vmax=1.0)
         if profile_and_rewards is not None:
             self._profile_and_rewards = profile_and_rewards
@@ -362,6 +371,7 @@ def __init__(
         cbar_selector.addWidget(radiobutton_1)
         cbar_selector.addWidget(radiobutton_2)
         cbar_selector.addWidget(radiobutton_3)
+        cbar_selector.addWidget(radiobutton_4)
         control = QtWidgets.QHBoxLayout()
         control.addLayout(left_control)
         control.addLayout(cbar_selector)
@@ -390,9 +400,18 @@ def __init__(
         else:
             self.resize(xlim * 4, ylim * 3)
 
+        self._self_terminate = self_terminate
+
+    def _check_exit(self) -> None:
+        if self._mgl_widget.exitable() and self._self_terminate:
+            print("Safely exited app because it reached the final frame")
+            self.close()
+
+    @functools.cache
     def _get_rewards(self, unique_id: int) -> dict[str, float]:
         filtered = self._profile_and_rewards.filter(pc.field("unique_id") == unique_id)
-        return filtered.drop(["birthtime", "parent", "unique_id"]).to_pydict()
+        d = filtered.drop(["birthtime", "parent", "unique_id"]).to_pydict()
+        return {k: v[0] for k, v in d.items()}
 
     @functools.cache
     def _get_n_children(self, unique_id: int) -> int:
@@ -445,6 +464,20 @@ def _get_colors(self, step_index: int) -> NDArray:
             value = np.zeros(self._n_max_agents)
             for slot, uid in zip(log["slots"], log["unique_id"]):
                 value[slot] = self._get_n_children(uid)
+        elif self._cbar_state is CBarState.FOOD_REWARD:
+            title = "Food Reward"
+            cm = self._n_children_cm
+            value = np.zeros(self._n_max_agents)
+            for slot, uid in zip(log["slots"], log["unique_id"]):
+                rew = self._get_rewards(uid)
+                if "scale_food" in rew:
+                    rew_food = rew["w_food"] * (10 ** rew["scale_food"])
+                elif "food" in rew:
+                    rew_food = rew["food"]
+                else:
+                    warnings.warn("Unsupported reward")
+                    rew_food = 0.0
+                value[slot] = rew_food
         else:
             warnings.warn(f"Invalid cbar state {self._cbar_state}")
             return np.zeros((self._n_max_agents, 4))
@@ -494,6 +527,12 @@ def cbarNChildren(self, checked: bool) -> None:
             self._cbar_state = CBarState.N_CHILDREN
             self._cbar_changed = True
 
+    @Slot(bool)
+    def cbarFood(self, checked: bool) -> None:
+        if checked:
+            self._cbar_state = CBarState.FOOD_REWARD
+            self._cbar_changed = True
+
 
 def start_widget(widget_cls: type[QtWidgets.QWidget], **kwargs) -> None:
     app = QtWidgets.QApplication([])

From b0a1f6aa571d30c2cf53585cc38244358d71d3ad Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 2 Feb 2024 11:27:05 +0900
Subject: [PATCH 235/337] [widget] Fixed minmax

---
 experiments/cf_asexual_evo.py   |  8 ++++++++
 src/emevo/analysis/qt_widget.py | 25 ++++++++++++++++---------
 2 files changed, 24 insertions(+), 9 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index d2c6db1c..db858185 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -2,6 +2,7 @@
  evolution with Circle Foraging"""
 import dataclasses
 import enum
+import json
 from pathlib import Path
 from typing import Optional, cast
 
@@ -553,6 +554,7 @@ def widget(
     log_path: Optional[Path] = None,
     self_terminate: bool = False,
     profile_and_rewards_path: Optional[Path] = None,
+    cm_fixed_minmax: str = "",
     env_override: str = "",
 ) -> None:
     from emevo.analysis.qt_widget import CFEnvReplayWidget, start_widget
@@ -582,6 +584,11 @@ def widget(
 
         profile_and_rewards = pq.read_table(profile_and_rewards_path)
 
+    if len(cm_fixed_minmax) > 0:
+        cm_fixed_minmax_dict = json.loads(cm_fixed_minmax)
+    else:
+        cm_fixed_minmax_dict = {}
+
     start_widget(
         CFEnvReplayWidget,
         xlim=int(cfconfig.xlim[1]),
@@ -594,6 +601,7 @@ def widget(
         step_offset=step_offset,
         self_terminate=self_terminate,
         profile_and_rewards=profile_and_rewards,
+        cm_fixed_minmax=cm_fixed_minmax_dict,
     )
 
 
diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index f48eb013..c630e261 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -52,8 +52,8 @@ def _mgl_qsurface_fmt() -> QSurfaceFormat:
     return fmt
 
 
-N_MAX_SCAN: int = 10240
-N_MAX_CACHED_LOG: int = 200
+N_MAX_SCAN: int = 20480
+N_MAX_CACHED_LOG: int = 100
 
 
 @jax.jit
@@ -278,11 +278,11 @@ def updateValues(self, title: str, values: dict[str, float | list[float]]) -> No
         self.chart.setTitle(title)
 
 
-class CBarState(enum.Enum):
-    AGE = 1
-    ENERGY = 2
-    N_CHILDREN = 3
-    FOOD_REWARD = 4
+class CBarState(str, enum.Enum):
+    AGE = "age"
+    ENERGY = "energy"
+    N_CHILDREN = "n-children"
+    FOOD_REWARD = "food-reward"
 
 
 class CFEnvReplayWidget(QtWidgets.QWidget):
@@ -301,6 +301,7 @@ def __init__(
         step_offset: int = 0,
         log_ds: ds.Dataset | None = None,
         profile_and_rewards: pa.Table | None = None,
+        cm_fixed_minmax: dict[str, tuple[float, float]] | None = None,
     ) -> None:
         super().__init__()
 
@@ -356,6 +357,7 @@ def __init__(
         self._n_children_cm = mpl.colormaps["PuBuGn"]
         self._food_cm = mpl.colormaps["YlOrRd"]
         self._norm = mc.Normalize(vmin=0.0, vmax=1.0)
+        self._cm_fixed_minmax = {} if cm_fixed_minmax is None else cm_fixed_minmax
         if profile_and_rewards is not None:
             self._profile_and_rewards = profile_and_rewards
             self._reward_widget = BarChart(self._get_rewards(1))  # type: ignore
@@ -481,8 +483,13 @@ def _get_colors(self, step_index: int) -> NDArray:
         else:
             warnings.warn(f"Invalid cbar state {self._cbar_state}")
             return np.zeros((self._n_max_agents, 4))
-        self._norm.vmin = np.amin(value)  # type: ignore
-        self._norm.vmax = np.amax(value)  # type: ignore
+        if self._cbar_state.value in self._cm_fixed_minmax:
+            self._norm.vmin, self._norm.vmax = self._cm_fixed_minmax[
+                self._cbar_state.value
+            ]
+        else:
+            self._norm.vmin = float(np.amin(value))
+            self._norm.vmax = float(np.amax(value))
         if self._cbar_changed:
             self._cbar_renderer.render(self._norm, cm, title)
             self._cbar_changed = False

From 705de4835d9ca5c982c99e4764862451ac809324 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 2 Feb 2024 13:49:17 +0900
Subject: [PATCH 236/337] Address ruff warnings

---
 src/emevo/analysis/qt_widget.py | 40 +++++++++++++++++++++------------
 1 file changed, 26 insertions(+), 14 deletions(-)

diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index c630e261..e60c633c 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import enum
-import functools
 import sys
 import warnings
 from collections import deque
@@ -139,7 +138,7 @@ def paintGL(self) -> None:
             else:
                 self._ctx = moderngl.create_context(require=410)
             if self._ctx.error != "GL_NO_ERROR":
-                warnings.warn(f"The qfollowing error occured: {self._ctx.error}")
+                warnings.warn(f"The qfollowing error occured: {self._ctx.error}", stacklevel=1)
             self._fbo = self._ctx.detect_framebuffer()
             self._renderer = self._make_renderer(self._ctx)
             self._initialized = True
@@ -206,6 +205,7 @@ def __init__(
         self.chart.setTitle(title)
         if animation:
             self.chart.setAnimationOptions(QChart.AnimationOption.SeriesAnimations)
+
         else:
             self.chart.setAnimationOptions(QChart.AnimationOption.NoAnimation)
 
@@ -241,7 +241,7 @@ def _make_barset(self, name: str, value: float | list[float]) -> QBarSet:
             for v in value:
                 barset.append(v)
         else:
-            warnings.warn(f"Invalid value for barset: {value}")
+            warnings.warn(f"Invalid value for barset: {value}", stacklevel=1)
         self.barsets[name] = barset
         self.series.append(barset)
         return barset
@@ -319,6 +319,9 @@ def __init__(
             get_colors=None if log_ds is None else self._get_colors,
         )
         self._n_max_agents = env.n_max_agents
+        # cache
+        self._cached_rewards = {}
+        self._cached_n_children = {}
         # Log / step
         self._log_ds = log_ds
         self._log_cached = {}
@@ -355,7 +358,7 @@ def __init__(
         self._value_cm = mpl.colormaps["YlOrRd"]
         self._energy_cm = mpl.colormaps["YlGnBu"]
         self._n_children_cm = mpl.colormaps["PuBuGn"]
-        self._food_cm = mpl.colormaps["YlOrRd"]
+        self._food_cm = mpl.colormaps["plasma"]
         self._norm = mc.Normalize(vmin=0.0, vmax=1.0)
         self._cm_fixed_minmax = {} if cm_fixed_minmax is None else cm_fixed_minmax
         if profile_and_rewards is not None:
@@ -401,28 +404,37 @@ def __init__(
             self.resize(xlim * 3, ylim * 3)
         else:
             self.resize(xlim * 4, ylim * 3)
-
         self._self_terminate = self_terminate
 
+
     def _check_exit(self) -> None:
         if self._mgl_widget.exitable() and self._self_terminate:
             print("Safely exited app because it reached the final frame")
             self.close()
 
-    @functools.cache
     def _get_rewards(self, unique_id: int) -> dict[str, float]:
+        if unique_id in self._cached_rewards:
+            return self._cached_rewards[unique_id]
         filtered = self._profile_and_rewards.filter(pc.field("unique_id") == unique_id)
-        d = filtered.drop(["birthtime", "parent", "unique_id"]).to_pydict()
-        return {k: v[0] for k, v in d.items()}
+        rd = filtered.drop(["birthtime", "parent", "unique_id"]).to_pydict()
+        rd = {k: v[0] for k, v in rd.items()}
+        self._cached_rewards[unique_id] = rd
+        return rd
 
-    @functools.cache
     def _get_n_children(self, unique_id: int) -> int:
         if self._profile_and_rewards is None:
-            warnings.warn("N children requires profile_an_rewards.parquet")
+            warnings.warn(
+                "N children requires profile_an_rewards.parquet",
+                stacklevel=1,
+            )
             return 0
         if unique_id == 0:
             return 0
-        return len(self._profile_and_rewards.filter(pc.field("parent") == unique_id))
+        if unique_id in self._cached_n_children:
+            return self._cached_n_children[unique_id]
+        nc = len(self._profile_and_rewards.filter(pc.field("parent") == unique_id))
+        self._cached_n_children[unique_id] = nc
+        return nc
 
     def _get_log(self, step: int) -> dict[str, NDArray]:
         assert self._log_ds is not None
@@ -468,7 +480,7 @@ def _get_colors(self, step_index: int) -> NDArray:
                 value[slot] = self._get_n_children(uid)
         elif self._cbar_state is CBarState.FOOD_REWARD:
             title = "Food Reward"
-            cm = self._n_children_cm
+            cm = self._food_cm
             value = np.zeros(self._n_max_agents)
             for slot, uid in zip(log["slots"], log["unique_id"]):
                 rew = self._get_rewards(uid)
@@ -477,11 +489,11 @@ def _get_colors(self, step_index: int) -> NDArray:
                 elif "food" in rew:
                     rew_food = rew["food"]
                 else:
-                    warnings.warn("Unsupported reward")
+                    warnings.warn("Unsupported reward", stacklevel=1)
                     rew_food = 0.0
                 value[slot] = rew_food
         else:
-            warnings.warn(f"Invalid cbar state {self._cbar_state}")
+            warnings.warn(f"Invalid cbar state {self._cbar_state}", stacklevel=1)
             return np.zeros((self._n_max_agents, 4))
         if self._cbar_state.value in self._cm_fixed_minmax:
             self._norm.vmin, self._norm.vmax = self._cm_fixed_minmax[

From 4887925589252759e367ea05f25e3bdd810292ce Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 5 Feb 2024 17:28:49 +0900
Subject: [PATCH 237/337] Remove pygraphvis from requirements

---
 pyproject.toml          | 2 +-
 requirements/jupyter.in | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 26103b44..80af5da4 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -32,11 +32,11 @@ dependencies = [
 dynamic = ["version"]
 
 [project.optional-dependencies]
+# pygraphviz >= 1.0 is also required to draw phylogenetic treee, but excluded here for Github CI
 analysis = [
     "matplotlib >= 3.0",
     "networkx >= 3.0",
     "polars >= 0.20",
-    "pygraphviz >= 1.0",
     "PySide6 >= 6.5",
 ]
 video = ["imageio-ffmpeg >= 0.4"]
diff --git a/requirements/jupyter.in b/requirements/jupyter.in
index 17013ef0..fe2b74c0 100644
--- a/requirements/jupyter.in
+++ b/requirements/jupyter.in
@@ -7,4 +7,5 @@ jupyterlab_code_formatter
 jupyterlab-lsp
 matplotlib
 polars
+pygraphviz
 seaborn
\ No newline at end of file

From 0b951276fb75763fe6c4201376f4ff54d99fcb2c Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 5 Feb 2024 18:11:25 +0900
Subject: [PATCH 238/337] [WIP] Multi food source

---
 src/emevo/environments/circle_foraging.py | 109 +++++++++++++++++-----
 src/emevo/environments/env_utils.py       |  80 ++++++++++------
 tests/test_env_utils.py                   |  20 ++--
 tests/test_placement.py                   |   2 +
 4 files changed, 154 insertions(+), 57 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 98cf0d1f..b6dbdb79 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -304,17 +304,37 @@ def _nonzero(arr: jax.Array, n: int) -> jax.Array:
     return jnp.cumsum(bincount)
 
 
+def _as_list(obj: Any) -> list[Any]:
+    if isinstance(obj, list):
+        return obj
+    else:
+        return [obj]
+
+
 _MaybeLocatingFn = Union[LocatingFn, str, tuple[str, ...]]
 _MaybeNumFn = Union[ReprNumFn, str, tuple[str, ...]]
 
 
+def _assert_n_food_sources(loc: Any, num: Any) -> int:
+    is_loc_list = isinstance(loc, list)
+    is_num_list = isinstance(num, list)
+    if is_loc_list and is_num_list:
+        n = len(loc)
+        assert n == len(num), "Number of food sources doesn't match"
+        return n
+    elif is_loc_list or is_num_list:
+        raise ValueError("Both of num and loc fns should be list")
+    else:
+        return 1
+
+
 class CircleForaging(Env):
     def __init__(
         self,
         n_initial_agents: int = 6,
         n_max_agents: int = 100,
         n_max_foods: int = 40,
-        food_num_fn: ReprNumFn | str | tuple[str, ...] = "constant",
+        food_num_fn: _MaybeNumFn | list[_MaybeNumFn] = "constant",
         food_loc_fn: _MaybeLocatingFn | list[_MaybeLocatingFn] = "gaussian",
         agent_loc_fn: LocatingFn | str | tuple[str, ...] = "uniform",
         xlim: tuple[float, float] = (0.0, 200.0),
@@ -360,11 +380,24 @@ def __init__(
         self._agent_radius = agent_radius
         self._food_radius = food_radius
         self._foodloc_interval = foodloc_interval
-        self._food_loc_fn, self._initial_foodloc_state = self._make_food_loc_fn(
-            food_loc_fn
-        )
-        self._food_num_fn, self._initial_foodnum_state = self._make_food_num_fn(
-            food_num_fn
+        self._n_food_sources = _assert_n_food_sources(food_loc_fn, food_num_fn)
+        self._food_loc_fns, initial_foodloc_states = [], []
+        self._food_num_fns, initial_foodnum_states = [], []
+        for maybe_loc_fn in _as_list(food_loc_fn):
+            fn, state = self._make_food_loc_fn(maybe_loc_fn)
+            self._food_loc_fns.append(fn)
+            initial_foodloc_states.append(state)
+        for maybe_num_fn in _as_list(food_num_fn):
+            fn, state = self._make_food_num_fn(maybe_num_fn)
+            self._food_num_fns.append(fn)
+            initial_foodnum_states.append(state)
+        self._initial_foodloc_state = jax.tree_map(
+            lambda *args: jnp.concatenate([arg.reshape(1) for arg in args]),
+            *initial_foodloc_states,
+        )
+        self._initial_foodnum_state = jax.tree_map(
+            lambda *args: jnp.concatenate(args),
+            *initial_foodnum_states,
         )
         self._agent_loc_fn, self._initial_agentloc_state = self._make_agent_loc_fn(
             agent_loc_fn
@@ -377,10 +410,10 @@ def __init__(
         self._energy_share_ratio = energy_share_ratio
         # Initial numbers
         assert n_max_agents > n_initial_agents
-        assert n_max_foods > self._food_num_fn.initial
+        self._n_initial_foods = sum([num_fn.initial for num_fn in self._food_num_fns])
+        assert n_max_foods > self._n_initial_foods
         self._n_initial_agents = n_initial_agents
         self.n_max_agents = n_max_agents
-        self._n_initial_foods = self._food_num_fn.initial
         self._n_max_foods = n_max_foods
         self._max_place_attempts = max_place_attempts
         # Physics
@@ -433,16 +466,21 @@ def __init__(
                 shaped=self._physics.shaped,
             )
         )
-        self._place_food = jax.jit(
-            functools.partial(
-                place,
-                n_trial=self._max_place_attempts,
-                radius=self._food_radius,
-                coordinate=self._coordinate,
-                loc_fn=self._food_loc_fn,
-                shaped=self._physics.shaped,
+
+        self._place_food_fns = []
+        for loc_fn in self._food_loc_fns:
+            place_fn = jax.jit(
+                functools.partial(
+                    place,
+                    n_trial=self._max_place_attempts,
+                    radius=self._food_radius,
+                    coordinate=self._coordinate,
+                    loc_fn=loc_fn,
+                    shaped=self._physics.shaped,
+                )
             )
-        )
+            self._place_food_fns.append(place_fn)
+
         if newborn_loc == "uniform":
 
             def place_newborn_uniform(
@@ -459,6 +497,7 @@ def place_newborn_uniform(
                     shaped=self._physics.shaped,
                     loc_state=state,
                     key=key,
+                    n_steps=0,
                     stated=stated,
                 )
 
@@ -488,6 +527,7 @@ def place_newborn_neighbor(
                     shaped=self._physics.shaped,
                     loc_state=state,
                     key=key,
+                    n_steps=0,
                     stated=stated,
                 )
 
@@ -804,9 +844,14 @@ def _initialize_physics_state(
         )
         keys = jax.random.split(key, self._n_initial_agents + self._n_initial_foods)
         agent_failed = 0
-        agentloc_state = self._initial_foodloc_state
+        agentloc_state = self._initial_agentloc_state
         for i, key in enumerate(keys[: self._n_initial_agents]):
-            xy, ok = self._init_agent(loc_state=agentloc_state, key=key, stated=stated)
+            xy, ok = self._init_agent(
+                loc_state=agentloc_state,
+                key=key,
+                n_steps=i,
+                stated=stated,
+            )
             if ok:
                 stated = stated.nested_replace(
                     "circle.p.xy",
@@ -814,6 +859,7 @@ def _initialize_physics_state(
                 )
                 agentloc_state = agentloc_state.increment()
             else:
+                del xy
                 agent_failed += 1
 
         if agent_failed > 0:
@@ -821,15 +867,28 @@ def _initialize_physics_state(
 
         food_failed = 0
         foodloc_state = self._initial_foodloc_state
+        food_increment = jnp.zeros(self._n_food_sources, dtype=jnp.int32)
         for i, key in enumerate(keys[self._n_initial_agents :]):
-            xy, ok = self._place_food(loc_state=foodloc_state, key=key, stated=stated)
+            idx = i % self._n_food_sources
+            xy, ok = self._place_food_fns[idx](
+                loc_state=foodloc_state.get_slice(idx),
+                key=key,
+                n_steps=i,
+                stated=stated,
+            )
             if ok:
                 stated = stated.nested_replace(
                     "static_circle.p.xy",
                     stated.static_circle.p.xy.at[i].set(xy),
                 )
-                foodloc_state = foodloc_state.increment()
+                # Set food label
+                stated = stated.nested_replace(
+                    "static_circle.label",
+                    stated.static_circle.label.at[i].set(idx),
+                )
+                foodloc_state = foodloc_state.increment(food_increment.at[idx].set(1))
             else:
+                del xy
                 food_failed += 1
 
         if food_failed > 0:
@@ -852,7 +911,13 @@ def _remove_and_reproduce_foods(
             sd.static_circle.p.xy,
         )
         is_active = jnp.logical_and(sd.static_circle.is_active, jnp.logical_not(eaten))
-        food_num = self._food_num_fn(food_num.eaten(jnp.sum(eaten)))
+        eaten_per_source = (
+            jnp.zeros(self._n_food_sources, dtype=jnp.int32)
+            .at[sd.static_circle.label]
+            .add(eaten)
+        )
+        food_num = food_num.eaten(eaten_per_source)
+        food_num = self._food_num_fn()
         # Generate new foods
         first_inactive = first_true(jnp.logical_not(is_active))
         new_food, ok = self._place_food(loc_state=food_loc, key=key, stated=sd)
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index 3c47cbc5..c39fcee2 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -21,7 +21,6 @@
 class FoodNumState:
     current: jax.Array
     internal: jax.Array
-    n_called: jax.Array
 
     def appears(self) -> jax.Array:
         return (self.internal - self.current) >= 1.0
@@ -30,7 +29,6 @@ def eaten(self, n: int | jax.Array) -> Self:
         return FoodNumState(
             current=self.current - n,
             internal=self.internal - n,
-            n_called=self.n_called,
         )
 
     def recover(self, n: int | jax.Array = 1) -> Self:
@@ -40,14 +38,16 @@ def _update(self, internal: jax.Array) -> Self:
         return FoodNumState(
             current=self.current,
             internal=internal,
-            n_called=self.n_called + 1,
         )
 
+    def get_slice(self, index: int) -> Self:
+        return jax.tree_map(lambda x: x[index], self)
+
 
 class ReprNumFn(Protocol):
     initial: int
 
-    def __call__(self, state: FoodNumState) -> FoodNumState:
+    def __call__(self, n_steps: int, state: FoodNumState) -> FoodNumState:
         ...
 
 
@@ -55,7 +55,7 @@ def __call__(self, state: FoodNumState) -> FoodNumState:
 class ReprNumConstant:
     initial: int
 
-    def __call__(self, state: FoodNumState) -> FoodNumState:
+    def __call__(self, _: int, state: FoodNumState) -> FoodNumState:
         # Do nothing here
         return state._update(jnp.array(self.initial, dtype=jnp.float32))
 
@@ -65,7 +65,7 @@ class ReprNumLinear:
     initial: int
     dn_dt: float
 
-    def __call__(self, state: FoodNumState) -> FoodNumState:
+    def __call__(self, _: int, state: FoodNumState) -> FoodNumState:
         # Increase the number of foods by dn_dt
         internal = jnp.fmax(state.current, state.internal)
         max_value = jnp.array(self.initial, dtype=jnp.float32)
@@ -78,7 +78,7 @@ class ReprNumLogistic:
     growth_rate: float
     capacity: float
 
-    def __call__(self, state: FoodNumState) -> FoodNumState:
+    def __call__(self, _: int, state: FoodNumState) -> FoodNumState:
         internal = jnp.fmax(state.current, state.internal)
         dn_dt = self.growth_rate * internal * (1 - internal / self.capacity)
         return state._update(internal + dn_dt)
@@ -109,8 +109,8 @@ def __init__(
     def initial(self) -> int:
         return self._numfn_list[0].initial
 
-    def __call__(self, state: FoodNumState) -> FoodNumState:
-        index = jnp.digitize(state.n_called, bins=self._intervals)
+    def __call__(self, n_steps: int, state: FoodNumState) -> FoodNumState:
+        index = jnp.digitize(n_steps, bins=self._intervals)
         return jax.lax.switch(index, self._numfn_list, state)
 
 
@@ -136,9 +136,8 @@ def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn, FoodNumState]:
 
         initial = fn.initial
         state = FoodNumState(
-            current=jnp.array(int(initial), dtype=jnp.int32),
-            internal=jnp.array(float(initial), dtype=jnp.float32),
-            n_called=jnp.array(1, dtype=jnp.int32),
+            current=jnp.ones(1, dtype=jnp.int32) * int(initial),
+            internal=jnp.ones(1, dtype=jnp.float32) * initial,
         )
         return cast(ReprNumFn, fn), state
 
@@ -215,13 +214,15 @@ def uniform(self, key: chex.PRNGKey) -> jax.Array:
 @chex.dataclass
 class LocatingState:
     n_produced: jax.Array
-    n_trial: jax.Array
 
     def increment(self, n: jax.Array | int = 1) -> Self:
-        return LocatingState(n_produced=self.n_produced + n, n_trial=self.n_trial + 1)
+        return LocatingState(n_produced=self.n_produced + n)
+
+    def get_slice(self, index: int) -> Self:
+        return jax.tree_map(lambda x: x[index], self)
 
 
-LocatingFn = Callable[[chex.PRNGKey, LocatingState], jax.Array]
+LocatingFn = Callable[[chex.PRNGKey, int, LocatingState], jax.Array]
 
 
 class Locating(str, enum.Enum):
@@ -235,9 +236,9 @@ class Locating(str, enum.Enum):
     UNIFORM = "uniform"
 
     def __call__(self, *args: Any, **kwargs: Any) -> tuple[LocatingFn, LocatingState]:
+        # Make sure it has shape () because it's also used for agents as singleton
         state = LocatingState(
             n_produced=jnp.array(0, dtype=jnp.int32),
-            n_trial=jnp.array(0, dtype=jnp.int32),
         )
         if self is Locating.GAUSSIAN:
             return loc_gaussian(*args, **kwargs), state
@@ -259,7 +260,12 @@ def loc_gaussian(mean: ArrayLike, stddev: ArrayLike) -> LocatingFn:
     mean_a = jnp.array(mean)
     std_a = jnp.array(stddev)
     shape = mean_a.shape
-    return lambda key, _: jax.random.normal(key, shape=shape) * std_a + mean_a
+
+    def sample(key: chex.PRNGKey, _n_steps: int, _state: LocatingState) -> jax.Array:
+        del _n_steps, _state
+        return jax.random.normal(key, shape=shape) * std_a + mean_a
+
+    return sample
 
 
 def loc_gaussian_mixture(
@@ -272,7 +278,8 @@ def loc_gaussian_mixture(
     probs_a = jnp.array(probs)
     n = probs_a.shape[0]
 
-    def sample(key: chex.PRNGKey, _: LocatingState) -> jax.Array:
+    def sample(key: chex.PRNGKey, _n_steps: int, _state: LocatingState) -> jax.Array:
+        del _n_steps, _state
         k1, k2 = jax.random.split(key)
         i = jax.random.choice(k1, n, p=probs_a)
         mi, si = mean_a[i], stddev_a[i]
@@ -282,7 +289,11 @@ def sample(key: chex.PRNGKey, _: LocatingState) -> jax.Array:
 
 
 def loc_uniform(coordinate: Coordinate) -> LocatingFn:
-    return lambda key, _: coordinate.uniform(key)
+    def sample(key: chex.PRNGKey, _n_steps: int, _state: LocatingState) -> jax.Array:
+        del _n_steps, _state
+        return coordinate.uniform(key)
+
+    return sample
 
 
 class LocPeriodic:
@@ -290,8 +301,14 @@ def __init__(self, *locations: ArrayLike) -> None:
         self._locations = jnp.array(locations)
         self._n = self._locations.shape[0]
 
-    def __call__(self, _: chex.PRNGKey, state: LocatingState) -> jax.Array:
-        return self._locations[state.n_trial % self._n]
+    def __call__(
+        self,
+        _key: chex.PRNGKey,
+        _n_steps: int,
+        state: LocatingState,
+    ) -> jax.Array:
+        del _key, _n_steps
+        return self._locations[state.n_produced % self._n]
 
 
 def _collect_loc_fns(fns: Iterable[tuple[str, ...] | LocatingFn]) -> list[LocatingFn]:
@@ -318,9 +335,14 @@ def __init__(
         self._interval = interval
         self._n = len(self._locfn_list)
 
-    def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
+    def __call__(
+        self,
+        key: chex.PRNGKey,
+        n_steps: int,
+        state: LocatingState,
+    ) -> jax.Array:
         index = (state.n_produced // self._interval) % self._n
-        return jax.lax.switch(index, self._locfn_list, key, state)
+        return jax.lax.switch(index, self._locfn_list, key, n_steps, state)
 
 
 class LocScheduled:
@@ -336,8 +358,13 @@ def __init__(
             intervals = [intervals * (i + 1) for i in range(len(self._locfn_list))]
         self._intervals = jnp.array(intervals, dtype=jnp.int32)
 
-    def __call__(self, key: chex.PRNGKey, state: LocatingState) -> jax.Array:
-        index = jnp.digitize(state.n_trial, bins=self._intervals)
+    def __call__(
+        self,
+        key: chex.PRNGKey,
+        n_steps: int,
+        state: LocatingState,
+    ) -> jax.Array:
+        index = jnp.digitize(n_steps, bins=self._intervals)
         return jax.lax.switch(index, self._locfn_list, key, state)
 
 
@@ -352,11 +379,12 @@ def place(
     loc_fn: LocatingFn,
     loc_state: LocatingState,
     key: chex.PRNGKey,
+    n_steps: int,
     shaped: ShapeDict,
     stated: StateDict,
 ) -> tuple[jax.Array, jax.Array]:
     keys = jax.random.split(key, n_trial)
-    locations = jax.vmap(loc_fn, in_axes=(0, None))(keys, loc_state)
+    locations = jax.vmap(loc_fn, in_axes=(0, None, None))(keys, n_steps, loc_state)
     overlap = jax.vmap(circle_overlap, in_axes=(None, None, 0, None))(
         shaped,
         stated,
diff --git a/tests/test_env_utils.py b/tests/test_env_utils.py
index f2259647..635fc3d8 100644
--- a/tests/test_env_utils.py
+++ b/tests/test_env_utils.py
@@ -38,7 +38,7 @@ def test_square_coordinate(key: chex.PRNGKey) -> None:
 
 def test_loc_gaussian(key: chex.PRNGKey) -> None:
     loc_g, state = Locating.GAUSSIAN((3.0, 3.0), (1.0, 1.0))
-    loc = jax.vmap(loc_g, in_axes=(0, None))(jax.random.split(key, 10), state)
+    loc = jax.vmap(loc_g, in_axes=(0, None, None))(jax.random.split(key, 10), 0, state)
     chex.assert_shape(loc, (10, 2))
     x_mean = jnp.mean(loc[:, 0])
     y_mean = jnp.mean(loc[:, 1])
@@ -47,7 +47,7 @@ def test_loc_gaussian(key: chex.PRNGKey) -> None:
 
 def test_loc_uniform(key: chex.PRNGKey) -> None:
     loc_u, state = Locating.UNIFORM(CircleCoordinate((3.0, 3.0), 3.0))
-    loc = jax.vmap(loc_u, in_axes=(0, None))(jax.random.split(key, 10), state)
+    loc = jax.vmap(loc_u, in_axes=(0, None, None))(jax.random.split(key, 10), 0, state)
     chex.assert_shape(loc, (10, 2))
     bigger_circle = CircleCoordinate((3.0, 3.0), 4.0)
     assert jnp.all(jax.vmap(bigger_circle.contains_circle)(loc, jnp.ones(10)))
@@ -59,7 +59,7 @@ def test_loc_gm(key: chex.PRNGKey) -> None:
         ((0.0, 0.0), (10.0, 10.0)),
         ((1.0, 1.0), (1.0, 1.0)),
     )
-    loc = jax.vmap(loc_gm, in_axes=(0, None))(jax.random.split(key, 20), state)
+    loc = jax.vmap(loc_gm, in_axes=(0, None, None))(jax.random.split(key, 20), 0, state)
     chex.assert_shape(loc, (20, 2))
     x_mean = jnp.mean(loc[:, 0])
     y_mean = jnp.mean(loc[:, 1])
@@ -70,7 +70,7 @@ def test_loc_periodic(key: chex.PRNGKey) -> None:
     points = [(0.0, 0.0), (1.0, 1.0), (2.0, 2.0)]
     loc_p, state = Locating.PERIODIC(*points)
     for i in range(10):
-        loc = loc_p(key, state)
+        loc = loc_p(key, i, state)
         state = state.increment()
         assert jnp.all(loc == jnp.array(points[i % 3]))
 
@@ -79,8 +79,9 @@ def test_loc_switching(key: chex.PRNGKey) -> None:
     loc_g, _ = Locating.GAUSSIAN((3.0, 3.0), (1.0, 1.0))
     loc_u, _ = Locating.UNIFORM(CircleCoordinate((3.0, 3.0), 3.0))
     loc_s, state = Locating.SWITCHING(10, loc_g, loc_u)
-    loc = jax.vmap(loc_s)(
+    loc = jax.vmap(loc_s, in_axes=(0, None, 0))(
         jax.random.split(key, 10),
+        0,
         jax.tree_map(lambda a: jnp.tile(a, (10,)), state),
     )
     chex.assert_shape(loc, (10, 2))
@@ -88,8 +89,9 @@ def test_loc_switching(key: chex.PRNGKey) -> None:
     y_mean = jnp.mean(loc[:, 1])
     assert (x_mean - 3) ** 2 < 1.0 and (y_mean - 3) ** 2 < 1.0
 
-    loc = jax.vmap(loc_s)(
+    loc = jax.vmap(loc_s, in_axes=(0, None, 0))(
         jax.random.split(key, 10),
+        0,
         jax.tree_map(lambda a: jnp.tile(a * 10, (10,)), state),
     )
     chex.assert_shape(loc, (10, 2))
@@ -99,6 +101,6 @@ def test_loc_switching(key: chex.PRNGKey) -> None:
 
 def test_foodnum_const() -> None:
     const, state = ReprNum.CONSTANT(10)
-    assert const(state.eaten(3)).appears()
-    assert const(state.eaten(3).recover(2)).appears()
-    assert not const(state.eaten(3).recover(3)).appears()
+    assert const(0, state.eaten(3)).appears()
+    assert const(0, state.eaten(3).recover(2)).appears()
+    assert not const(0, state.eaten(3).recover(3)).appears()
diff --git a/tests/test_placement.py b/tests/test_placement.py
index b8f12735..23922a2f 100644
--- a/tests/test_placement.py
+++ b/tests/test_placement.py
@@ -49,6 +49,7 @@ def test_place_agents(key) -> None:
             loc_fn=initloc_fn,
             loc_state=initloc_state,
             key=key,
+            n_steps=0,
             shaped=space.shaped,
             stated=stated,
         )
@@ -83,6 +84,7 @@ def test_place_foods(key) -> None:
             loc_fn=reprloc_fn,
             loc_state=reprloc_state,
             key=key,
+            n_steps=0,
             shaped=space.shaped,
             stated=stated,
         )

From bf03074c866d68f260b3253dffa31cbf8f5fa4d5 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 6 Feb 2024 17:45:53 +0900
Subject: [PATCH 239/337] Complete implementation of multi food source

---
 src/emevo/environments/circle_foraging.py | 91 ++++++++++++-----------
 src/emevo/environments/env_utils.py       | 14 ++--
 2 files changed, 57 insertions(+), 48 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index b6dbdb79..407fcbc1 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -31,8 +31,8 @@
     ReprNum,
     ReprNumFn,
     SquareCoordinate,
-    first_true,
     loc_gaussian,
+    nth_true,
     place,
 )
 from emevo.environments.phyjax2d import Circle, Position, Raycast, ShapeDict
@@ -91,9 +91,9 @@ def as_array(self) -> jax.Array:
 class CFState:
     physics: StateDict
     solver: VelocitySolver
-    food_num: FoodNumState
+    food_num: list[FoodNumState]
     agent_loc: LocatingState
-    food_loc: LocatingState
+    food_loc: list[LocatingState]
     key: chex.PRNGKey
     step: jax.Array
     unique_id: UniqueID
@@ -381,24 +381,16 @@ def __init__(
         self._food_radius = food_radius
         self._foodloc_interval = foodloc_interval
         self._n_food_sources = _assert_n_food_sources(food_loc_fn, food_num_fn)
-        self._food_loc_fns, initial_foodloc_states = [], []
-        self._food_num_fns, initial_foodnum_states = [], []
+        self._food_loc_fns, self._initial_foodloc_states = [], []
+        self._food_num_fns, self._initial_foodnum_states = [], []
         for maybe_loc_fn in _as_list(food_loc_fn):
             fn, state = self._make_food_loc_fn(maybe_loc_fn)
             self._food_loc_fns.append(fn)
-            initial_foodloc_states.append(state)
+            self._initial_foodloc_states.append(state)
         for maybe_num_fn in _as_list(food_num_fn):
             fn, state = self._make_food_num_fn(maybe_num_fn)
             self._food_num_fns.append(fn)
-            initial_foodnum_states.append(state)
-        self._initial_foodloc_state = jax.tree_map(
-            lambda *args: jnp.concatenate([arg.reshape(1) for arg in args]),
-            *initial_foodloc_states,
-        )
-        self._initial_foodnum_state = jax.tree_map(
-            lambda *args: jnp.concatenate(args),
-            *initial_foodnum_states,
-        )
+            self._initial_foodnum_states.append(state)
         self._agent_loc_fn, self._initial_agentloc_state = self._make_agent_loc_fn(
             agent_loc_fn
         )
@@ -673,6 +665,7 @@ def step(
             food_key,
             jnp.max(c2sc, axis=0),
             stated,
+            state.step,
             state.food_num,
             state.food_loc,
         )
@@ -790,7 +783,7 @@ def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
             solver=self._physics.init_solver(),
             agent_loc=agent_loc,
             food_loc=food_loc,
-            food_num=self._initial_foodnum_state,
+            food_num=[s for s in self._initial_foodnum_states],
             key=key,
             step=jnp.array(0, dtype=jnp.int32),
             unique_id=unique_id,
@@ -813,7 +806,7 @@ def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
     def _initialize_physics_state(
         self,
         key: chex.PRNGKey,
-    ) -> tuple[StateDict, LocatingState, LocatingState]:
+    ) -> tuple[StateDict, LocatingState, list[LocatingState]]:
         # Set segment
         stated = self._physics.shaped.zeros_state()
         assert stated.circle is not None
@@ -866,12 +859,11 @@ def _initialize_physics_state(
             warnings.warn(f"Failed to place {agent_failed} agents!", stacklevel=1)
 
         food_failed = 0
-        foodloc_state = self._initial_foodloc_state
-        food_increment = jnp.zeros(self._n_food_sources, dtype=jnp.int32)
+        foodloc_states = [s for s in self._initial_foodloc_states]
         for i, key in enumerate(keys[self._n_initial_agents :]):
             idx = i % self._n_food_sources
             xy, ok = self._place_food_fns[idx](
-                loc_state=foodloc_state.get_slice(idx),
+                loc_state=foodloc_states[idx],
                 key=key,
                 n_steps=i,
                 stated=stated,
@@ -886,7 +878,7 @@ def _initialize_physics_state(
                     "static_circle.label",
                     stated.static_circle.label.at[i].set(idx),
                 )
-                foodloc_state = foodloc_state.increment(food_increment.at[idx].set(1))
+                foodloc_states[idx] = foodloc_states[idx].increment()
             else:
                 del xy
                 food_failed += 1
@@ -894,16 +886,17 @@ def _initialize_physics_state(
         if food_failed > 0:
             warnings.warn(f"Failed to place {food_failed} foods!", stacklevel=1)
 
-        return stated, agentloc_state, foodloc_state
+        return stated, agentloc_state, foodloc_states
 
     def _remove_and_reproduce_foods(
         self,
         key: chex.PRNGKey,
         eaten: jax.Array,
         sd: StateDict,
-        food_num: FoodNumState,
-        food_loc: LocatingState,
-    ) -> tuple[StateDict, FoodNumState, LocatingState]:
+        n_steps: jax.Array,
+        food_num_states: list[FoodNumState],
+        food_loc_states: list[LocatingState],
+    ) -> tuple[StateDict, list[FoodNumState], list[LocatingState]]:
         # Remove foods
         xy = jnp.where(
             jnp.expand_dims(eaten, axis=1),
@@ -916,23 +909,37 @@ def _remove_and_reproduce_foods(
             .at[sd.static_circle.label]
             .add(eaten)
         )
-        food_num = food_num.eaten(eaten_per_source)
-        food_num = self._food_num_fn()
-        # Generate new foods
-        first_inactive = first_true(jnp.logical_not(is_active))
-        new_food, ok = self._place_food(loc_state=food_loc, key=key, stated=sd)
-        place = jnp.logical_and(jnp.logical_and(ok, food_num.appears()), first_inactive)
-        xy = jnp.where(
-            jnp.expand_dims(place, axis=1),
-            jnp.expand_dims(new_food, axis=0),
-            xy,
-        )
-        is_active = jnp.logical_or(is_active, place)
-        p = replace(sd.static_circle.p, xy=xy)
-        sc = replace(sd.static_circle, p=p, is_active=is_active)
-        sd = replace(sd, static_circle=sc)
-        incr = jnp.sum(place)
-        return sd, food_num.recover(incr), food_loc.increment(incr)
+        sc = sd.static_circle
+        for i in range(self._n_food_sources):
+            food_num = self._food_num_fns[i](
+                n_steps,
+                food_num_states[i].eaten(eaten_per_source[i]),
+            )
+            food_loc = food_loc_states[i]
+            # Generate new foods
+            first_inactive = nth_true(jnp.logical_not(is_active), i + 1)
+            new_food, ok = self._place_food_fns[i](
+                loc_state=food_loc,
+                key=key,
+                n_steps=n_steps,
+                stated=sd,
+            )
+            place = jnp.logical_and(
+                jnp.logical_and(ok, food_num.appears()),
+                first_inactive,
+            )
+            xy = jnp.where(
+                jnp.expand_dims(place, axis=1),
+                jnp.expand_dims(new_food, axis=0),
+                xy,
+            )
+            is_active = jnp.logical_or(is_active, place)
+            p = replace(sc.p, xy=xy)
+            sc = replace(sc, p=p, is_active=is_active)
+            incr = jnp.sum(place)
+            food_num_states[i] = food_num.recover(incr)
+            food_loc_states[i] = food_loc.increment(incr)
+        return replace(sd, static_circle=sc), food_num_states, food_loc_states
 
     def visualizer(
         self,
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index c39fcee2..469fa1a8 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -136,8 +136,8 @@ def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn, FoodNumState]:
 
         initial = fn.initial
         state = FoodNumState(
-            current=jnp.ones(1, dtype=jnp.int32) * int(initial),
-            internal=jnp.ones(1, dtype=jnp.float32) * initial,
+            current=jnp.array(int(initial), dtype=jnp.int32),
+            internal=jnp.array(float(initial), dtype=jnp.float32),
         )
         return cast(ReprNumFn, fn), state
 
@@ -166,7 +166,9 @@ def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]:
         return (cx - r, cx + r), (cy - r, cy + r)
 
     def contains_circle(
-        self, center: jax.Array, radius: jax.Array | float
+        self,
+        center: jax.Array,
+        radius: jax.Array | float,
     ) -> jax.Array:
         a2b = center - jnp.array(self.center)
         distance = jnp.linalg.norm(a2b, ord=2)
@@ -368,8 +370,8 @@ def __call__(
         return jax.lax.switch(index, self._locfn_list, key, state)
 
 
-def first_true(boolean_array: jax.Array) -> jax.Array:
-    return jnp.logical_and(boolean_array, jnp.cumsum(boolean_array) == 1)
+def nth_true(boolean_array: jax.Array, n: int) -> jax.Array:
+    return jnp.logical_and(boolean_array, jnp.cumsum(boolean_array) == n)
 
 
 def place(
@@ -393,5 +395,5 @@ def place(
     )
     contains_fn = jax.vmap(coordinate.contains_circle, in_axes=(0, None))
     ok = jnp.logical_and(contains_fn(locations, radius), jnp.logical_not(overlap))
-    mask = jnp.expand_dims(first_true(ok), axis=1)
+    mask = jnp.expand_dims(nth_true(ok, 1), axis=1)
     return jnp.sum(mask * locations, axis=0), jnp.any(ok)

From 14682ffacda3c71a4f96fe96ca155724a0c661b7 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 6 Feb 2024 18:24:07 +0900
Subject: [PATCH 240/337] Multi

---
 config/env/20240206-multi.toml            | 36 ++++++++++++++++++++
 src/emevo/environments/circle_foraging.py | 40 +++++++++--------------
 src/emevo/exp_utils.py                    |  1 +
 3 files changed, 53 insertions(+), 24 deletions(-)
 create mode 100644 config/env/20240206-multi.toml

diff --git a/config/env/20240206-multi.toml b/config/env/20240206-multi.toml
new file mode 100644
index 00000000..a4c6cb0a
--- /dev/null
+++ b/config/env/20240206-multi.toml
@@ -0,0 +1,36 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 80
+n_food_sources = 2
+food_num_fn = [
+    ["logistic", 20, 0.01, 40],
+    ["logistic", 20, 0.01, 40],
+]
+food_loc_fn = [
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["gaussian", [120.0, 90.0], [48.0, 36.0]],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 407fcbc1..f2b53dd2 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -304,36 +304,17 @@ def _nonzero(arr: jax.Array, n: int) -> jax.Array:
     return jnp.cumsum(bincount)
 
 
-def _as_list(obj: Any) -> list[Any]:
-    if isinstance(obj, list):
-        return obj
-    else:
-        return [obj]
-
-
 _MaybeLocatingFn = Union[LocatingFn, str, tuple[str, ...]]
 _MaybeNumFn = Union[ReprNumFn, str, tuple[str, ...]]
 
 
-def _assert_n_food_sources(loc: Any, num: Any) -> int:
-    is_loc_list = isinstance(loc, list)
-    is_num_list = isinstance(num, list)
-    if is_loc_list and is_num_list:
-        n = len(loc)
-        assert n == len(num), "Number of food sources doesn't match"
-        return n
-    elif is_loc_list or is_num_list:
-        raise ValueError("Both of num and loc fns should be list")
-    else:
-        return 1
-
-
 class CircleForaging(Env):
     def __init__(
         self,
         n_initial_agents: int = 6,
         n_max_agents: int = 100,
         n_max_foods: int = 40,
+        n_food_sources: int = 1,
         food_num_fn: _MaybeNumFn | list[_MaybeNumFn] = "constant",
         food_loc_fn: _MaybeLocatingFn | list[_MaybeLocatingFn] = "gaussian",
         agent_loc_fn: LocatingFn | str | tuple[str, ...] = "uniform",
@@ -380,14 +361,23 @@ def __init__(
         self._agent_radius = agent_radius
         self._food_radius = food_radius
         self._foodloc_interval = foodloc_interval
-        self._n_food_sources = _assert_n_food_sources(food_loc_fn, food_num_fn)
+        self._n_food_sources = n_food_sources
         self._food_loc_fns, self._initial_foodloc_states = [], []
         self._food_num_fns, self._initial_foodnum_states = [], []
-        for maybe_loc_fn in _as_list(food_loc_fn):
+        if n_food_sources > 1:
+            assert isinstance(food_loc_fn, (list, tuple)) and n_food_sources == len(
+                food_loc_fn
+            )
+            assert isinstance(food_num_fn, (list, tuple)) and n_food_sources == len(
+                food_num_fn
+            )
+        else:
+            food_loc_fn, food_num_fn = [food_loc_fn], [food_num_fn]  # type: ignore
+        for maybe_loc_fn in food_loc_fn:  # type: ignore
             fn, state = self._make_food_loc_fn(maybe_loc_fn)
             self._food_loc_fns.append(fn)
             self._initial_foodloc_states.append(state)
-        for maybe_num_fn in _as_list(food_num_fn):
+        for maybe_num_fn in food_num_fn:  # type: ignore
             fn, state = self._make_food_num_fn(maybe_num_fn)
             self._food_num_fns.append(fn)
             self._initial_foodnum_states.append(state)
@@ -860,8 +850,10 @@ def _initialize_physics_state(
 
         food_failed = 0
         foodloc_states = [s for s in self._initial_foodloc_states]
+        n_initial = [fn.initial for fn in self._food_num_fns]
+        n_initial_cumsum = jnp.cumsum(jnp.array(n_initial))
         for i, key in enumerate(keys[self._n_initial_agents :]):
-            idx = i % self._n_food_sources
+            idx = jnp.digitize(i, n_initial_cumsum).astype(np.uint8)
             xy, ok = self._place_food_fns[idx](
                 loc_state=foodloc_states[idx],
                 key=key,
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index dd4e9228..7550b1d9 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -33,6 +33,7 @@ class CfConfig:
     n_initial_agents: int = 6
     n_max_agents: int = 100
     n_max_foods: int = 40
+    n_food_sources: int = 1
     food_num_fn: Union[str, Tuple[str, ...]] = "constant"
     food_loc_fn: Union[str, Tuple[str, ...]] = "gaussian"
     agent_loc_fn: Union[str, Tuple[str, ...]] = "uniform"

From 779970bee2fe578c6c57e9ac09ced7793376fc19 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 7 Feb 2024 12:14:10 +0900
Subject: [PATCH 241/337] [Fix] Set food labels correctly

---
 config/env/20240206-multi.toml            | 4 ++--
 src/emevo/environments/circle_foraging.py | 5 +++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/config/env/20240206-multi.toml b/config/env/20240206-multi.toml
index a4c6cb0a..0c8d96c9 100644
--- a/config/env/20240206-multi.toml
+++ b/config/env/20240206-multi.toml
@@ -3,8 +3,8 @@ n_max_agents = 150
 n_max_foods = 80
 n_food_sources = 2
 food_num_fn = [
-    ["logistic", 20, 0.01, 40],
-    ["logistic", 20, 0.01, 40],
+    ["logistic", 15, 0.01, 30],
+    ["logistic", 15, 0.01, 30],
 ]
 food_loc_fn = [
    ["gaussian", [360.0, 270.0], [48.0, 36.0]],
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index f2b53dd2..1a0dc747 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -902,13 +902,13 @@ def _remove_and_reproduce_foods(
             .add(eaten)
         )
         sc = sd.static_circle
+        # Regenerate food for each source
         for i in range(self._n_food_sources):
             food_num = self._food_num_fns[i](
                 n_steps,
                 food_num_states[i].eaten(eaten_per_source[i]),
             )
             food_loc = food_loc_states[i]
-            # Generate new foods
             first_inactive = nth_true(jnp.logical_not(is_active), i + 1)
             new_food, ok = self._place_food_fns[i](
                 loc_state=food_loc,
@@ -927,7 +927,8 @@ def _remove_and_reproduce_foods(
             )
             is_active = jnp.logical_or(is_active, place)
             p = replace(sc.p, xy=xy)
-            sc = replace(sc, p=p, is_active=is_active)
+            label = jnp.where(place, i, sc.label)
+            sc = replace(sc, p=p, is_active=is_active, label=label)
             incr = jnp.sum(place)
             food_num_states[i] = food_num.recover(incr)
             food_loc_states[i] = food_loc.increment(incr)

From a95d5df5a7ba663aa5a380d4de523ff305d54580 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 7 Feb 2024 13:59:39 +0900
Subject: [PATCH 242/337] Address lint

---
 src/emevo/analysis/log_plotting.py |  6 +++---
 src/emevo/analysis/qt_widget.py    |  8 +++++---
 src/emevo/reward_fn.py             | 30 ++++++++++++++++++++++++++++++
 3 files changed, 38 insertions(+), 6 deletions(-)

diff --git a/src/emevo/analysis/log_plotting.py b/src/emevo/analysis/log_plotting.py
index 05aa7dec..68fb799f 100644
--- a/src/emevo/analysis/log_plotting.py
+++ b/src/emevo/analysis/log_plotting.py
@@ -47,7 +47,7 @@ def plot_rewards_3d(
     ax.set_xlabel(r1)
     ax.set_ylabel(r2)
     ax.set_zlabel("Birth Step")
-    if tree != None:
+    if tree is not None:
         x, y, z = scatter._offsets3d  # type: ignore
         x = x.data
         y = y.data
@@ -80,7 +80,7 @@ def plot_rewards_2d(
     palette = sns.color_palette("husl", len(labels))
     colors = [palette[label] for label in tr["label"]]
     ax.scatter(tr["birthtime"], tr[reward_axis], c=colors, s=5, marker="o")
-    if tree != None:
+    if tree is not None:
 
         def get_pos(ij: tuple[int, int]) -> tuple | None:
             stepi = tr.filter(pl.col("unique_id") == ij[0])
@@ -102,7 +102,7 @@ def get_pos(ij: tuple[int, int]) -> tuple | None:
         ax.add_collection(edge_collection)
 
     for label in labels:
-        tr_selected = tr.filter(pl.col(f"in-label-{label}") == True).to_pandas()
+        tr_selected = tr.filter(pl.col(f"in-label-{label}")).to_pandas()
         order = 2 if len(tr_selected) > 100 else 1
         sns.regplot(
             data=tr_selected,
diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index e60c633c..828589a5 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -138,7 +138,10 @@ def paintGL(self) -> None:
             else:
                 self._ctx = moderngl.create_context(require=410)
             if self._ctx.error != "GL_NO_ERROR":
-                warnings.warn(f"The qfollowing error occured: {self._ctx.error}", stacklevel=1)
+                warnings.warn(
+                    f"The qfollowing error occured: {self._ctx.error}",
+                    stacklevel=1,
+                )
             self._fbo = self._ctx.detect_framebuffer()
             self._renderer = self._make_renderer(self._ctx)
             self._initialized = True
@@ -267,7 +270,7 @@ def updateValues(self, title: str, values: dict[str, float | list[float]]) -> No
                 for i, vi in enumerate(value):
                     self.barsets[name].replace(i, vi)
             else:
-                warnings.warn(f"Invalid value for barset {value}")
+                warnings.warn(f"Invalid value for barset {value}", stacklevel=1)
 
         for name in list(self.barsets.keys()):
             if name not in values:
@@ -406,7 +409,6 @@ def __init__(
             self.resize(xlim * 4, ylim * 3)
         self._self_terminate = self_terminate
 
-
     def _check_exit(self) -> None:
         if self._mgl_widget.exitable() and self._self_terminate:
             print("Safely exited app because it reached the final frame")
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index f70979da..ae4feadb 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -72,6 +72,36 @@ def serialise(self) -> dict[str, float | NDArray]:
         return jax.tree_map(_item_or_np, self.serializer(self.weight))
 
 
+class SinhReward(RewardFn):
+    weight: jax.Array
+    scale: float
+    extractor: Callable[..., jax.Array]
+    serializer: Callable[[jax.Array], dict[str, jax.Array]]
+
+    def __init__(
+        self,
+        *,  # order of arguments are a bit confusing here...
+        key: chex.PRNGKey,
+        n_agents: int,
+        n_weights: int,
+        extractor: Callable[..., jax.Array],
+        serializer: Callable[[jax.Array], dict[str, jax.Array]],
+        scale: float = 2.0,
+        std: float = 1.0,
+        mean: float = 0.0,
+    ) -> None:
+        self.weight = jax.random.normal(key, (n_agents, n_weights)) * std + mean
+        self.extractor = extractor
+        self.serializer = serializer
+
+    def __call__(self, *args) -> jax.Array:
+        extracted = self.extractor(*args)
+        return jax.vmap(jnp.dot)(extracted, self.weight)
+
+    def serialise(self) -> dict[str, float | NDArray]:
+        return jax.tree_map(_item_or_np, self.serializer(self.weight))
+
+
 class ExponentialReward(RewardFn):
     weight: jax.Array
     scale: jax.Array

From 25ae6b4fff3f0423193407bece89bbe7d3ed91f4 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 7 Feb 2024 14:25:15 +0900
Subject: [PATCH 243/337] Update black

---
 pyproject.toml                         |  4 +++-
 src/emevo/__init__.py                  |  1 -
 src/emevo/analysis/qt_widget.py        |  1 +
 src/emevo/birth_and_death.py           |  1 +
 src/emevo/env.py                       |  7 +++----
 src/emevo/environments/env_utils.py    | 13 +++++--------
 src/emevo/environments/moderngl_vis.py |  1 +
 src/emevo/environments/phyjax2d.py     |  3 +--
 src/emevo/environments/registry.py     |  1 +
 src/emevo/exp_utils.py                 |  1 +
 src/emevo/reward_fn.py                 |  1 +
 src/emevo/spaces.py                    |  1 +
 src/emevo/visualizer.py                |  3 +--
 13 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 80af5da4..cccf0e98 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -64,9 +64,11 @@ profile = "black"
 
 [tool.ruff]
 line-length = 88
+
+[tool.ruff.lint]
 select = ["E", "F", "B", "UP"]
 
-[tool.ruff.per-file-ignores]
+[tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["F401"]
 "src/emevo/reward_fn.py" = ["B023"]
 # For pyserde
diff --git a/src/emevo/__init__.py b/src/emevo/__init__.py
index 9fff70a7..c7796801 100644
--- a/src/emevo/__init__.py
+++ b/src/emevo/__init__.py
@@ -3,7 +3,6 @@
 This package contains API definitions and some environment implementations.
 """
 
-
 from emevo.env import Env, Status, TimeStep, UniqueID
 from emevo.environments.registry import make, register
 from emevo.vec2d import Vec2d
diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index 828589a5..4a8aadf6 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -1,5 +1,6 @@
 """Qt widget with moderngl visualizer for advanced visualization.
 """
+
 from __future__ import annotations
 
 import enum
diff --git a/src/emevo/birth_and_death.py b/src/emevo/birth_and_death.py
index 2ba11197..fc898bcb 100644
--- a/src/emevo/birth_and_death.py
+++ b/src/emevo/birth_and_death.py
@@ -1,5 +1,6 @@
 """ Evaluate birth and death probabilities.
 """
+
 import dataclasses
 from typing import Protocol
 
diff --git a/src/emevo/env.py b/src/emevo/env.py
index 7de14615..eefb624a 100644
--- a/src/emevo/env.py
+++ b/src/emevo/env.py
@@ -1,4 +1,5 @@
 """Abstract environment API"""
+
 from __future__ import annotations
 
 import abc
@@ -92,8 +93,7 @@ def init_uniqueid(n: int, max_n: int) -> UniqueID:
 class ObsProtocol(Protocol):
     """Abstraction for agent's observation"""
 
-    def as_array(self) -> jax.Array:
-        ...
+    def as_array(self) -> jax.Array: ...
 
 
 OBS = TypeVar("OBS", bound="ObsProtocol")
@@ -108,8 +108,7 @@ class StateProtocol(Protocol):
     status: Status
     n_born_agents: jax.Array
 
-    def is_extinct(self) -> bool:
-        ...
+    def is_extinct(self) -> bool: ...
 
 
 STATE = TypeVar("STATE", bound="StateProtocol")
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index 469fa1a8..142b79c6 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -1,4 +1,5 @@
 """Place agent and food"""
+
 from __future__ import annotations
 
 import dataclasses
@@ -47,8 +48,7 @@ def get_slice(self, index: int) -> Self:
 class ReprNumFn(Protocol):
     initial: int
 
-    def __call__(self, n_steps: int, state: FoodNumState) -> FoodNumState:
-        ...
+    def __call__(self, n_steps: int, state: FoodNumState) -> FoodNumState: ...
 
 
 @dataclasses.dataclass(frozen=True)
@@ -143,16 +143,13 @@ def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn, FoodNumState]:
 
 
 class Coordinate(Protocol):
-    def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]:
-        ...
+    def bbox(self) -> tuple[tuple[float, float], tuple[float, float]]: ...
 
     def contains_circle(
         self, center: jax.Array, radius: jax.Array | float
-    ) -> jax.Array:
-        ...
+    ) -> jax.Array: ...
 
-    def uniform(self, key: chex.PRNGKey) -> jax.Array:
-        ...
+    def uniform(self, key: chex.PRNGKey) -> jax.Array: ...
 
 
 @dataclasses.dataclass
diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index 04f67ddf..a690516a 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -2,6 +2,7 @@
 A simple,  fast visualizer based on moderngl.
 Currently, only supports circles and lines.
 """
+
 from __future__ import annotations
 
 from typing import Callable, ClassVar
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 960ff503..696e6470 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -99,8 +99,7 @@ class _PositionLike(Protocol):
     angle: jax.Array  # Angular velocity (N,)
     xy: jax.Array  # (N, 2)
 
-    def __init__(self, angle: jax.Array, xy: jax.Array) -> None:
-        ...
+    def __init__(self, angle: jax.Array, xy: jax.Array) -> None: ...
 
     def batch_size(self) -> int:
         return self.angle.shape[0]
diff --git a/src/emevo/environments/registry.py b/src/emevo/environments/registry.py
index 96c1b298..1cdaa711 100644
--- a/src/emevo/environments/registry.py
+++ b/src/emevo/environments/registry.py
@@ -1,5 +1,6 @@
 """ Gym-like make/register system
 """
+
 from __future__ import annotations
 
 import dataclasses
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 7550b1d9..cf2e6987 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -1,4 +1,5 @@
 """Utility for experiments"""
+
 from __future__ import annotations
 
 import dataclasses
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index ae4feadb..c00cb199 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -1,4 +1,5 @@
 """Example of using circle foraging environment"""
+
 from __future__ import annotations
 
 import abc
diff --git a/src/emevo/spaces.py b/src/emevo/spaces.py
index 46dbb9cf..0d715177 100644
--- a/src/emevo/spaces.py
+++ b/src/emevo/spaces.py
@@ -1,4 +1,5 @@
 """Similar to gym.spaces.Space, but for jax"""
+
 from __future__ import annotations
 
 import abc
diff --git a/src/emevo/visualizer.py b/src/emevo/visualizer.py
index a1c863d8..3a9313df 100644
--- a/src/emevo/visualizer.py
+++ b/src/emevo/visualizer.py
@@ -13,8 +13,7 @@ def close(self) -> None:
         """Close this visualizer"""
         ...
 
-    def get_image(self) -> NDArray:
-        ...
+    def get_image(self) -> NDArray: ...
 
     def render(self, state: STATE, **kwargs) -> None:
         """Render image"""

From 205d72014b2af58335d598d7678b8f8c5c884482 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 7 Feb 2024 15:08:18 +0900
Subject: [PATCH 244/337] SinhReward

---
 experiments/cf_asexual_evo.py |  17 +++-
 notebooks/reward_fn.ipynb     | 147 ++++++++++++++++++++++------------
 src/emevo/reward_fn.py        |   7 +-
 3 files changed, 115 insertions(+), 56 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index db858185..3f8237b2 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -39,6 +39,7 @@
     RewardFn,
     SigmoidReward,
     SigmoidReward_01,
+    SinhReward,
     mutate_reward_fn,
     serialize_weight,
 )
@@ -62,6 +63,7 @@ class RewardKind(str, enum.Enum):
     EXPONENTIAL = "exponential"
     SIGMOID = "sigmoid"
     SIGMOID_01 = "sigmoid-01"
+    SINH = "sinh"
 
 
 @dataclasses.dataclass
@@ -100,6 +102,10 @@ def extract_sigmoid(
         return jnp.concatenate((collision, act_input), axis=1), energy
 
 
+def linear_reward_serializer(w: jax.Array) -> dict[str, jax.Array]:
+    return serialize_weight(w, ["agent", "food", "wall", "action"])
+
+
 def exp_reward_serializer(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
     w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
     scale_dict = serialize_weight(
@@ -456,10 +462,7 @@ def evolve(
         reward_fn_instance = LinearReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_linear,
-            serializer=lambda w: serialize_weight(
-                w,
-                ["agent", "food", "wall", "action"],
-            ),
+            serializer=linear_reward_serializer,
         )
     elif reward_fn == RewardKind.EXPONENTIAL:
         reward_fn_instance = ExponentialReward(
@@ -479,6 +482,12 @@ def evolve(
             extractor=reward_extracor.extract_sigmoid,
             serializer=sigmoid_reward_serializer,
         )
+    elif reward_fn == RewardKind.SINH:
+        reward_fn_instance = SinhReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_linear,
+            serializer=linear_reward_serializer,
+        )
     else:
         raise ValueError(f"Invalid reward_fn {reward_fn}")
 
diff --git a/notebooks/reward_fn.ipynb b/notebooks/reward_fn.ipynb
index 198d7447..16e9fdd8 100644
--- a/notebooks/reward_fn.ipynb
+++ b/notebooks/reward_fn.ipynb
@@ -2,37 +2,24 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "31f0ecac-d024-4106-8700-0f84004e753e",
    "metadata": {},
    "outputs": [],
    "source": [
     "import dataclasses\n",
-    "from typing import Any, Literal\n",
     "\n",
     "import ipywidgets as widgets\n",
     "import numpy as np\n",
-    "from emevo import birth_and_death as bd\n",
     "from matplotlib import pyplot as plt\n",
-    "from matplotlib.figure import Figure\n",
     "from matplotlib.lines import Line2D\n",
-    "from matplotlib.text import Text\n",
-    "from mpl_toolkits.mplot3d.art3d import Poly3DCollection\n",
-    "\n",
-    "from emevo.plotting import (\n",
-    "    vis_birth,\n",
-    "    vis_expected_n_children,\n",
-    "    vis_hazard,\n",
-    "    vis_lifetime,\n",
-    "    show_params_text,\n",
-    ")\n",
     "\n",
     "%matplotlib ipympl"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "id": "9de733db-cd24-4a67-ae28-f2e3ce2af415",
    "metadata": {},
    "outputs": [],
@@ -66,7 +53,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 17,
    "id": "df0fe701-8b83-4a0c-86f9-6d241cd930ea",
    "metadata": {},
    "outputs": [],
@@ -74,8 +61,6 @@
     "def sigmoid_reward_widget(\n",
     "    f,\n",
     "    energy_max: float = 40.0,\n",
-    "    alpha_max: float = 2.0,\n",
-    "    alpha_min: float = -2.0,\n",
     "    n_discr: int = 1000,\n",
     ") -> widgets.VBox:\n",
     "    fig = plt.figure(figsize=(6, 6))\n",
@@ -108,35 +93,65 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "id": "547967f9-2c4b-40bb-a244-fcad24150897",
+   "execution_count": 18,
+   "id": "a9fbd4a3-b9ef-437d-8db6-3771d6b1fef0",
    "metadata": {},
    "outputs": [
     {
      "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "571063db72b14c0d81aa156da8ec2aa6",
+       "version_major": 2,
+       "version_minor": 0
+      },
       "text/plain": [
-       "0.5"
+       "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=1.0, min=-1.0, step=0.002…"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f8660c8cb8b243dc984aba79588a9a51",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
-    "1 / (1.0 + np.exp(-0.0))"
+    "sigmoid_reward_widget(lambda e, a: 1.0 / (1.0 + np.exp(- e * a)))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "id": "a9fbd4a3-b9ef-437d-8db6-3771d6b1fef0",
+   "execution_count": 19,
+   "id": "64594795-61ee-46f9-b8f0-35325a5e2f56",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "772123856e224b60ad68d90b2bfc6957",
+       "model_id": "15f80edb7c334784a2719be036347b2a",
        "version_major": 2,
        "version_minor": 0
       },
@@ -144,25 +159,25 @@
        "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=1.0, min=-1.0, step=0.002…"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "01c1a95a4c4043ea8d60e4299a4995e8",
+       "model_id": "35eaa9d03a664a9fb725df6d2b14390a",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -175,45 +190,87 @@
     }
    ],
    "source": [
-    "sigmoid_reward_widget(lambda e, a: 1.0 / (1.0 + np.exp(- e * a)))"
+    "sigmoid_reward_widget(lambda e, a: 2.0 / (1.0 + np.exp(- e * a)) - (a > 0))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "id": "64594795-61ee-46f9-b8f0-35325a5e2f56",
+   "execution_count": 30,
+   "id": "b91dd971-aa16-43ca-95e5-b20341f89df1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sinh_reward_widget(\n",
+    "    f,\n",
+    "    alpha_max: float = 5.0,\n",
+    "    n_discr: int = 1000\n",
+    ") -> widgets.VBox:\n",
+    "    fig = plt.figure(figsize=(6, 6))\n",
+    "    ax = fig.add_subplot(111)\n",
+    "    ax.set_title(\"Sinh reward_fn\")\n",
+    "\n",
+    "    @dataclasses.dataclass\n",
+    "    class State:\n",
+    "        line: Line2D | None = None\n",
+    "\n",
+    "    state = State()\n",
+    "\n",
+    "    def update_figure(alpha: float = 0.0):\n",
+    "        if state.line is None:\n",
+    "            ax.grid(True, which=\"major\")\n",
+    "            ax.set_xlabel(\"W\", fontsize=12)\n",
+    "            ax.set_ylabel(\"Reward Coef\", fontsize=12)\n",
+    "            # ax.set_ylim((-1.0, 1.0))\n",
+    "        else:\n",
+    "            state.line.remove()\n",
+    "\n",
+    "        w = np.linspace(-1.0, 1.0, n_discr)\n",
+    "        state.line = ax.plot(w, f(w, alpha), color=\"xkcd:bluish purple\")[0]\n",
+    "        fig.canvas.draw()\n",
+    "        fig.canvas.flush_events()\n",
+    "\n",
+    "    interactive = widgets.interactive(\n",
+    "        update_figure, alpha=make_slider(0.0, alpha_max, logscale=False, n_steps=n_discr)\n",
+    "    )\n",
+    "    return widgets.VBox([interactive])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "71c3a640-8966-4b43-b233-558c5e0e3b24",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "3b6b52ecbe854f6e80c55ce82ab00d4c",
+       "model_id": "340796bd96c24048808059cc3c212322",
        "version_major": 2,
        "version_minor": 0
       },
       "text/plain": [
-       "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=1.0, min=-1.0, step=0.002…"
+       "VBox(children=(interactive(children=(FloatSlider(value=1.25, description='alpha', max=2.5, step=0.0025), Outpu…"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 31,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "524432b6b5be483ea79cfd578837f8dd",
+       "model_id": "508b2be48d584ded8e827df9c3c8de92",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAJYCAYAAAC+ZpjcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABEtUlEQVR4nO3deVhV5f7//9cGmVRwRBRRBKwcUtQcQsU0UY6aqQ160tLsZMcpU0/H1K/zqWjSLDO1OqmntLTJLEfSHDiRM2WDnlTMIYXUAgVFhPX7wx/70w4whpv23vh8XBdXrnvf6+b93ksuX6219sJmWZYlAAAAGOPh7AIAAADKGwIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWUA40aNBADz74oLPLuKYlS5bIZrPp6NGjfzjXHfopKzabTTNmzCjWPhcuXNDDDz+s2rVry2azaezYsWVSG4CiI2ABLmz//v265557FBoaKl9fX9WtW1fdunXTvHnznF0aXMjTTz+tJUuWaMSIEXrrrbf0wAMPOLsk4LpnsyzLcnYRAPL74osv1KVLF9WvX19DhgxR7dq1dfz4cX355Zc6fPiwDh06ZJ+blZUlDw8PeXl5ObHia8vJyVF2drZ8fHxks9muObdBgwbq3LmzlixZ8ucU50JsNpumT59erLNYt956qypUqKCEhISyKwxAsVRwdgEACvbUU0+pSpUq2rVrl6pWrerwWmpqqsO2j4/Pn1hZyXh6esrT07NMv8eVK1eUm5srb2/vMv0+pZGRkaFKlSoZXTM1NVVNmjQxuiaA0uESIeCiDh8+rKZNm+YLV5JUq1Yth+2C7ln6+uuvddttt8nPz08hISF68skntXjx4nz3QTVo0EB33HGHtmzZotatW8vPz0/NmjXTli1bJEkffvihmjVrJl9fX91yyy3at29fvno2b96s6OhoVapUSVWrVlWfPn30/fffO8wp6B4sy7L05JNPKiQkRBUrVlSXLl307bffFun9OXr0qGw2m1544QXNnTtXERER8vHx0XfffSdJOnDggO655x5Vr15dvr6+at26tVavXm3f/9dff5Wnp6defvll+9iZM2fk4eGhGjVq6Lcn90eMGKHatWvbt7dv3657771X9evXl4+Pj+rVq6dx48bp4sWLDjU++OCDqly5sg4fPqyePXvK399fgwYNknT1rOO4ceMUGBgof39/3XnnnTpx4kSRes+zZcsW2Ww2JScna82aNbLZbPb3OO+1lStX6qmnnlJISIh8fX3VtWtXh7OfAMoGZ7AAFxUaGqrExER98803uvnmm4u178mTJ9WlSxfZbDZNmjRJlSpV0htvvFHoma5Dhw5p4MCB+vvf/677779fL7zwgnr37q2FCxdq8uTJGjlypCQpLi5O/fv318GDB+XhcfX/zz777DP16NFD4eHhmjFjhi5evKh58+apQ4cO2rt3rxo0aFBondOmTdOTTz6pnj17qmfPntq7d6+6d++uy5cvF7nXxYsX69KlS3rkkUfk4+Oj6tWr69tvv1WHDh1Ut25dTZw4UZUqVdLKlSvVt29fffDBB+rXr5+qVq2qm2++Wdu2bdOYMWMkSQkJCbLZbDp37py+++47NW3aVNLVQBUdHW3/nu+9954yMzM1YsQI1ahRQzt37tS8efN04sQJvffeew71XblyRbGxserYsaNeeOEFVaxYUZL08MMP6+2339bAgQPVvn17bd68Wb169Spy35LUuHFjvfXWWxo3bpxCQkL0j3/8Q5IUGBhoD7LPPPOMPDw89PjjjystLU3PPfecBg0apB07dhTrewEoJguAS9q4caPl6elpeXp6WlFRUdaECROsDRs2WJcvX843NzQ01BoyZIh9+9FHH7VsNpu1b98++9jZs2et6tWrW5Ks5ORkh30lWV988YV9bMOGDZYky8/Pz/rxxx/t44sWLbIkWZ9//rl9rEWLFlatWrWss2fP2se++uory8PDwxo8eLB9bPHixQ7fOzU11fL29rZ69epl5ebm2udNnjzZkuTQT0GSk5MtSVZAQICVmprq8FrXrl2tZs2aWZcuXbKP5ebmWu3bt7duuOEG+9ioUaOsoKAg+/b48eOtTp06WbVq1bIWLFhgf99sNpv10ksv2edlZmbmqycuLs6y2WwO79eQIUMsSdbEiRMd5iYlJVmSrJEjRzqMDxw40JJkTZ8+/Zq9/15oaKjVq1cvh7HPP//ckmQ1btzYysrKso+/9NJLliRr//79xfoeAIqHS4SAi+rWrZsSExN155136quvvtJzzz2n2NhY1a1b1+FSV0HWr1+vqKgotWjRwj5WvXp1++Wp32vSpImioqLs2+3atZMk3X777apfv36+8SNHjkiSTp06paSkJD344IOqXr26fV7z5s3VrVs3rV27ttAaP/vsM12+fFmPPvqow03vxX3EwN13363AwED79rlz57R582b1799f58+f15kzZ3TmzBmdPXtWsbGx+uGHH3Ty5ElJUnR0tFJSUnTw4EFJV89UderUSdHR0dq+fbukq2e1LMtyOIPl5+dn/3NGRobOnDmj9u3by7KsAi+hjhgxwmE7733JO3NW0t6LYujQoQ73pOX1kXcMAZQNAhbgwtq0aaMPP/xQv/zyi3bu3KlJkybp/Pnzuueee+z3GhXkxx9/VMOGDfONFzQmySFESVKVKlUkSfXq1Stw/JdffrF/H0m66aab8q3ZuHFjnTlzRhkZGYXWKEk33HCDw3hgYKCqVatW4D4FCQsLc9g+dOiQLMvS1KlTFRgY6PA1ffp0Sf/3IYG8sLF9+3ZlZGRo3759io6OVqdOnewBa/v27QoICFBkZKT9exw7dsweKitXrqzAwEDddtttkqS0tDSHeipUqKCQkJB8vXt4eCgiIsJhvKD3sbR+f2zz3tu8YwigbHAPFuAGvL291aZNG7Vp00Y33nijhg4dqvfee88eGEqrsE/3FTZuudDTXX57NkmScnNzJUmPP/64YmNjC9wnL2gGBwcrLCxM27ZtU4MGDWRZlqKiohQYGKjHHntMP/74o7Zv36727dvb7znLyclRt27ddO7cOT3xxBNq1KiRKlWqpJMnT+rBBx+0f/88Pj4+9n2dwR2OIVAeEbAAN9O6dWtJVy/PFSY0NLTAT4qZ/vRYaGioJNkvsf3WgQMHVLNmzUIfSZC37w8//KDw8HD7+M8//1yqsyt5a3l5eSkmJuYP50dHR2vbtm0KCwtTixYt5O/vr8jISFWpUkXr16/X3r17NXPmTPv8/fv363//+5+WLl2qwYMH28fj4+OLXGNoaKhyc3N1+PBhh7NWBb2PANwTlwgBF/X5558XeJYh7/6da11Oio2NVWJiopKSkuxj586d07Jly4zWWKdOHbVo0UJLly7Vr7/+ah//5ptvtHHjRvXs2bPQfWNiYuTl5aV58+Y59Dl37txS1VSrVi117txZixYtKjCE/vzzzw7b0dHROnr0qFasWGG/ZOjh4aH27dtrzpw5ys7Odrj/Ku+M0G9rtixLL730UpFr7NGjhyQ5PCJCKn3vAFwHZ7AAF/Xoo48qMzNT/fr1U6NGjXT58mV98cUXWrFihRo0aKChQ4cWuu+ECRP09ttvq1u3bnr00Uftj2moX7++zp0794dPUi+O559/Xj169FBUVJT+9re/2R/TUKVKlWs+jTwwMFCPP/644uLidMcdd6hnz57at2+f1q1bp5o1a5aqpvnz56tjx45q1qyZhg0bpvDwcKWkpCgxMVEnTpzQV199ZZ+bF54OHjyop59+2j7eqVMnrVu3Tj4+PmrTpo19vFGjRoqIiNDjjz+ukydPKiAgQB988EGxzrq1aNFC9913n1599VWlpaWpffv22rRpE8+nAsoRAhbgol544QW99957Wrt2rV577TVdvnxZ9evX18iRIzVlypQCH0Cap169evr88881ZswYPf300woMDNSoUaNUqVIljRkzRr6+vsbqjImJ0fr16zV9+nRNmzZNXl5euu222/Tss8/muwH995588kn5+vpq4cKF+vzzz9WuXTtt3Lix2M+D+r0mTZpo9+7dmjlzppYsWaKzZ8+qVq1aatmypaZNm+Yw96abblKtWrWUmpqqjh072sfzglfbtm0dnh/m5eWlTz75RGPGjFFcXJx8fX3Vr18/jR492uFG+D/y5ptvKjAwUMuWLdOqVat0++23a82aNfk+WADAPfG7CIHryNixY7Vo0SJduHChzH9tDQBcz7gHCyinfv9rW86ePau33npLHTt2JFwBQBnjEiFQTkVFRalz585q3LixUlJS9O9//1vp6emaOnWqs0tDEeTk5OS7If/3KleurMqVK/9JFQEoDgIWUE717NlT77//vl577TXZbDa1atVK//73v9WpUydnl4YiOH78+B/ewzZ9+vRrfpAAgPNwDxYAuKBLly4pISHhmnPCw8MdniEGwHUQsAAAAAzjJncAAADDuAeriHJzc/XTTz/J39/f6EMaAQAo7yzL0vnz5xUcHOzU3835ZyJgFdFPP/3EAwABACiF48ePKyQkxNll/CkIWEXk7+8v6epfjoCAACNrZmdna+PGjerevbu8vLyMrOls9OQe6Mn1lbd+JHpyF2XRU3p6uurVq2f/t/R6QMAqorzLggEBAUYDVsWKFRUQEFCufjDpyfXRk+srb/1I9OQuyrKn6+kWm+vjQigAAMCfiIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGOZyAWvbtm3q3bu3goODZbPZtGrVqj/cZ8uWLWrVqpV8fHzUsGFDLVmypNC5zzzzjGw2m8aOHWusZgAAgN9yuYCVkZGhyMhIzZ8/v0jzk5OT1atXL3Xp0kVJSUkaO3asHn74YW3YsCHf3F27dmnRokVq3ry56bIBAADsKji7gN/r0aOHevToUeT5CxcuVFhYmGbPni1Jaty4sRISEvTiiy8qNjbWPu/ChQsaNGiQXn/9dT355JPG6wYAAMjjcgGruBITExUTE+MwFhsbm+8S4KhRo9SrVy/FxMQUKWBlZWUpKyvLvp2eni5Jys7OVnZ2dukL///X+u1/ywN6cg/05PrKWz8SPbmLsuipPL0/ReX2Aev06dMKCgpyGAsKClJ6erouXrwoPz8/vfvuu9q7d6927dpV5HXj4uI0c+bMfOMbN25UxYoVS133b8XHxxtdzxXQk3ugJ9dX3vqR6MldmOwpMzPT2Fruwu0D1h85fvy4HnvsMcXHx8vX17fI+02aNEnjx4+3b6enp6tevXrq3r27AgICjNSWnZ2t+Ph4devWTV5eXkbWdDZ6cg/05PrKWz8SPbmLsugp7yrQ9cTtA1bt2rWVkpLiMJaSkqKAgAD5+flpz549Sk1NVatWreyv5+TkaNu2bXrllVeUlZUlT0/PfOv6+PjIx8cn37iXl5fxH6KyWNPZ6Mk90JPrK2/9SPTkLkz2VN7em6Jw+4AVFRWltWvXOozFx8crKipKktS1a1ft37/f4fWhQ4eqUaNGeuKJJwoMVwAAAKXhcgHrwoULOnTokH07OTlZSUlJql69uurXr69Jkybp5MmT+s9//iNJGj58uF555RVNmDBBDz30kDZv3qyVK1dqzZo1kiR/f3/dfPPNDt+jUqVKqlGjRr5xAAAAE1zuOVi7d+9Wy5Yt1bJlS0nS+PHj1bJlS02bNk2SdOrUKR07dsw+PywsTGvWrFF8fLwiIyM1e/ZsvfHGGw6PaAAAAPgzudwZrM6dO8uyrEJfL+gp7Z07d9a+ffuK/D22bNlSgsoAAACKxuXOYAEAALg7AhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwlwtY27ZtU+/evRUcHCybzaZVq1b94T5btmxRq1at5OPjo4YNG2rJkiUOr8fFxalNmzby9/dXrVq11LdvXx08eLBsGgAAANc9lwtYGRkZioyM1Pz584s0Pzk5Wb169VKXLl2UlJSksWPH6uGHH9aGDRvsc7Zu3apRo0bpyy+/VHx8vLKzs9W9e3dlZGSUVRsAAOA6VsHZBfxejx491KNHjyLPX7hwocLCwjR79mxJUuPGjZWQkKAXX3xRsbGxkqT169c77LNkyRLVqlVLe/bsUadOncwVDwAAIBcMWMWVmJiomJgYh7HY2FiNHTu20H3S0tIkSdWrVy90TlZWlrKysuzb6enpkqTs7GxlZ2eXouL/k7eOqfVcAT25B3pyfeWtH4me3EVZ9FSe3p+islmWZTm7iMLYbDZ99NFH6tu3b6FzbrzxRg0dOlSTJk2yj61du1a9evVSZmam/Pz8HObn5ubqzjvv1K+//qqEhIRC150xY4ZmzpyZb3z58uWqWLFi8ZsBAOA6lZmZqYEDByotLU0BAQHOLudP4fZnsIpr1KhR+uabb64ZriRp0qRJGj9+vH07PT1d9erVU/fu3Y395cjOzlZ8fLy6desmLy8vI2s6Gz25B3pyfeWtH4me3EVZ9JR3Feh64vYBq3bt2kpJSXEYS0lJUUBAQL6zV6NHj9ann36qbdu2KSQk5Jrr+vj4yMfHJ9+4l5eX8R+isljT2ejJPdCT6ytv/Uj05C5M9lTe3puicLlPERZXVFSUNm3a5DAWHx+vqKgo+7ZlWRo9erQ++ugjbd68WWFhYX92mQAA4DricgHrwoULSkpKUlJSkqSrj2FISkrSsWPHJF29dDd48GD7/OHDh+vIkSOaMGGCDhw4oFdffVUrV67UuHHj7HNGjRqlt99+W8uXL5e/v79Onz6t06dP6+LFi39qbwAA4PrgcgFr9+7datmypVq2bClJGj9+vFq2bKlp06ZJkk6dOmUPW5IUFhamNWvWKD4+XpGRkZo9e7beeOMN+yMaJGnBggVKS0tT586dVadOHfvXihUr/tzmAADAdcHl7sHq3LmzrvXBxt8/pT1vn3379hW6jwt/UBIAAJRDLncGCwAAwN0RsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYVOWCtXr1aP/30U1nWAgAAUC4UOWD169dPW7ZssW+Hh4dr9erVZVETAACAWytywPL399evv/5q3z569KguXLhQFjUBAAC4tQpFndi2bVs99dRTSklJUZUqVSRJa9eu1enTpwvdx2azady4caWvEgAAwI0UOWC9+uqrGjx4sP71r39Juhqeli9fruXLlxe6DwELAABcj4ocsBo2bKgvvvhCly5dUmpqqho0aKC5c+eqT58+ZVkfAACA2ylywMrj6+ur+vXra/r06br99tsVGhpaFnUBAAC4rWIHrDzTp0+3//nUqVNKTU1Vw4YNValSJSOFAQAAuKtSPWj0448/VqNGjRQSEqJWrVppx44dkqQzZ86oZcuWWrVqlYkaAQAA3EqJA9Ynn3yiu+66SzVr1tT06dNlWZb9tZo1a6pu3bpavHixkSIBAADcSYkD1qxZs9SpUyclJCRo1KhR+V6PiorSvn37SlUcAACAOypxwPrmm2/Uv3//Ql8PCgpSampqSZcHAABwWyUOWBUrVlRGRkahrx85ckQ1atQo6fIAAABuq8QBq0uXLlq6dKmuXLmS77XTp0/r9ddfV/fu3UtVHAAAgDsqccB66qmndOLECbVp00aLFi2SzWbThg0bNGXKFDVr1kyWZTk8ygEAAOB6UeKAddNNNykhIUE1atTQ1KlTZVmWnn/+eT399NNq1qyZtm/frgYNGhgsFQAAwD2U+EGjktS0aVN99tln+uWXX3To0CHl5uYqPDxcgYGBpuoDAABwO6UKWHmqVaumNm3amFgKAADA7ZXqSe7p6emaOXOm2rZtq6CgIAUFBalt27aaNWuW0tPTTdUIAADgVkocsH766Se1bNlSM2fO1IULF9ShQwd16NBBGRkZmjFjhlq1aqVTp06ZrBUAAMAtlPgS4RNPPKHTp0/r008/Vc+ePR1eW7dune69915NnDhRS5cuLXWRAAAA7qTEZ7DWr1+vsWPH5gtXktSjRw+NGTNGa9euLVVxAAAA7qjEASsjI0NBQUGFvl67du1rPukdAACgvCpxwGrSpIneeecdXb58Od9r2dnZeuedd9SkSZNSFQcAAOCOSnUP1oABA9S2bVuNHDlSN954oyTp4MGDWrhwob7++mutWLHCWKEAAADuosQB695771VGRoYmTpyo4cOHy2azSZIsy1KtWrX05ptv6p577jFWKAAAgLso1YNGH3zwQd1///3avXu3fvzxR0lSaGioWrdurQoVjDzDFAAAwO2UOgVVqFBBt956q2699VYT9QAAALi9Yt3kfurUKTVq1EhTp0695rwpU6aocePGSk1NLVVxAAAA7qhYAeull17SuXPn9MQTT1xz3hNPPKFz585p3rx5pSoOAADAHRUrYK1Zs0b33XefKleufM15/v7+GjhwoFavXl2q4gAAANxRsQLW4cOH1bx58yLNbdq0qQ4dOlSiogAAANxZsQKWp6dngQ8WLUh2drY8PEr8HFMAAAC3VawEFBERoYSEhCLN/e9//6uIiIgSFQUAAODOihWw+vXrp/fee0+JiYnXnPfll19q5cqV6tevX6mKAwAAcEfFCljjx49XSEiIunfvrmeffVYnT550eP3kyZN69tln1b17d4WEhGjcuHFGiwUAAHAHxQpY/v7++uyzzxQREaFJkyapfv36ql69ukJDQ1W9enXVr19fkyZNUlhYmOLj4xUQEFBWdQMAALisYj/JPTw8XHv27NH777+v1atX68CBA0pPT1dYWJgaNWqk3r1765577uFX5QAAgOtWiVKQp6enBgwYoAEDBpiuBwAAwO3xHAUAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgWJEf0zBr1qxiL26z2TR16tRi7wcAAODOihywZsyYkW/MZrNJkizLyjduWRYBCwAAXJeKfIkwNzfX4ev48eNq1qyZ7rvvPu3cuVNpaWlKS0vTjh079Ne//lWRkZE6fvx4WdYOAADgkkp8D9aoUaN0ww036O2331br1q3l7+8vf39/tWnTRsuWLVNERIRGjRpV7HW3bdum3r17Kzg4WDabTatWrfrDfbZs2aJWrVrJx8dHDRs21JIlS/LNmT9/vho0aCBfX1+1a9dOO3fuLHZtAAAARVHigLV582bdfvvthb7etWtXbdq0qdjrZmRkKDIyUvPnzy/S/OTkZPXq1UtdunRRUlKSxo4dq4cfflgbNmywz1mxYoXGjx+v6dOna+/evYqMjFRsbKxSU1OLXR8AAMAfKfFvZPb19VViYqJGjBhR4OtffPGFfH19i71ujx491KNHjyLPX7hwocLCwjR79mxJUuPGjZWQkKAXX3xRsbGxkqQ5c+Zo2LBhGjp0qH2fNWvW6M0339TEiROLXaMJlmXp8kVLOZc9dPmipdwruU6pw7Qr2fTkDujJ9ZW3fiR6chd5Pf3+/moUT4kD1qBBg/Tyyy+ratWqevTRRxURESFJOnz4sF5++WUtX75cY8aMMVZoYRITExUTE+MwFhsbq7Fjx0qSLl++rD179mjSpEn21z08PBQTE6PExMRC183KylJWVpZ9Oz09XZKUnZ2t7OzsUtd9+aKlKT3PSWqj7S+dK/V6roWe3AM9ub7y1o9ET+6ijW6/PVu2AJuR1Uz8u+luShywnn32WZ05c0avvPKK5s+fLw+Pq1cbc3NzZVmW7rvvPj377LPGCi3M6dOnFRQU5DAWFBSk9PR0Xbx4Ub/88otycnIKnHPgwIFC142Li9PMmTPzjW/cuFEVK1Ysdd05lz0ktSn1OgAAlIXNmzfL09vMWbnMzEwj67iTEgcsb29vvfXWW/rnP/+ptWvX6scff5QkhYaGqkePHoqMjDRWpDNMmjRJ48ePt2+np6erXr166t69uwICAkq9vmVZuv32bPu9bF5eXqVe0xVkZ9OTO6An11fe+pHoyV3k9RTb83Z5e3sbWTPvKtD1pEQBKzMzU/fff7/uvvtuDRo0SM2bNzddV5HVrl1bKSkpDmMpKSkKCAiQn5+fPD095enpWeCc2rVrF7quj4+PfHx88o17eXkZ+yGyBdjk6Z2rSgHe5egHk57cAT25vvLWj0RP7iKvJ29vcz2Vl/emOEr0KcKKFSvqs88+c4lTflFRUfk+rRgfH6+oqChJV8+03XLLLQ5zcnNztWnTJvscAAAAk0r8mIaOHTte8ybxkrpw4YKSkpKUlJQk6epjGJKSknTs2DFJVy/dDR482D5/+PDhOnLkiCZMmKADBw7o1Vdf1cqVKzVu3Dj7nPHjx+v111/X0qVL9f3332vEiBHKyMiwf6oQAADApBLfg/XKK68oNjZWU6ZM0fDhwxUSEmKkoN27d6tLly727bz7oIYMGaIlS5bo1KlT9rAlSWFhYVqzZo3GjRunl156SSEhIXrjjTfsj2iQpAEDBujnn3/WtGnTdPr0abVo0ULr16/Pd+M7AACACSUOWJGRkbpy5Yri4uIUFxenChUq5LtnyWazKS0trVjrdu7c+ZrP3ijoKe2dO3fWvn37rrnu6NGjNXr06GLVAgAAUBIlDlh33323/Zc9AwAA4P+UOGAVdCYJAAAApbjJHQAAAAUr8RmsPCdOnNC+ffuUlpam3Nz8T3z97Sf+AAAArgclDliXLl3SkCFD9MEHHyg3N1c2m81+c/pv780iYAEAgOtNiS8RTp48WR9++KGeeuopbdmyRZZlaenSpdq4caP9V+V89dVXJmsFAABwCyUOWO+//76GDh2qJ554Qk2bNpUk1a1bVzExMfr0009VtWpVzZ8/31ihAAAA7qLEASs1NVVt27aVJPn5+UmSMjIy7K/ffffd+vDDD0tZHgAAgPspccAKCgrS2bNnJV393YTVqlXTwYMH7a+np6fr0qVLpa8QAADAzZT4Jvd27dopISFBTzzxhCSpd+/eev7551WnTh3l5ubqxRdf1K233mqsUAAAAHdR4jNYY8aMUXh4uLKysiRJ//rXv1S1alU98MADGjJkiKpUqaKXX37ZWKEAAADuosRnsDp27KiOHTvat+vVq6fvv/9e+/fvl6enpxo1aqQKFUr9mC0AAAC3YzQBeXh4KDIy0uSSAAAAbqfEASs4OFjR0dH2L4IVAADAVSUOWH369FFCQoLef/99SVJAQIDat2+vTp06KTo6Wm3atJGXl5exQgEAANxFiQPWggULJEm//PKLtm/fru3btyshIUHTpk3TlStX5OPjo3bt2unzzz83ViwAAIA7KPU9WNWqVdOdd96pO++8U8ePH9e6des0Z84c/e9//9O2bdtM1AgAAOBWShWwvv/+e/vZq+3bt+v48eOqUqWKoqKiNHToUEVHR5uqEwAAwG2UOGAFBgbq3LlzqlWrlqKjo/WPf/zDfrO7zWYzWSMAAIBbKfGDRs+ePSubzaZGjRqpcePGaty4sW644QbCFQAAuO6V+AzWzz//rISEBG3fvl3r169XXFycJKlFixb2Rzd07NhRNWvWNFYsAACAOyhxwKpRo4b69OmjPn36SJIyMzOVmJio7du3a+XKlZo7d65sNpuuXLlirFgAAAB3YORJ7j/88IO2b9+ubdu2afv27UpOTpZ09T4tAACA602JA9Yrr7yibdu2KSEhQSkpKbIsS2FhYYqOjtbkyZMVHR2tG2+80WStAAAAbqHEAWvs2LG6+eabdffdd9vvuapTp47J2gAAANxSiQPW2bNnVaVKFZO1AAAAlAslfkzDb8PVqVOn9NVXXykjI8NIUQAAAO6sxAFLkj7++GM1atRIISEhatWqlXbs2CFJOnPmjFq2bKlVq1aZqBEAAMCtlDhgffLJJ7rrrrtUs2ZNTZ8+XZZl2V+rWbOm6tatq8WLFxspEgAAwJ2UOGDNmjVLnTp1UkJCgkaNGpXv9aioKO3bt69UxQEAALijEgesb775Rv379y/09aCgIKWmppZ0eQAAALdV4oBVsWLFa97UfuTIEdWoUaOkywMAALitEgesLl26aOnSpQX+KpzTp0/r9ddfV/fu3UtVHAAAgDsqccB66qmndOLECbVp00aLFi2SzWbThg0bNGXKFDVr1kyWZWn69OkmawUAAHALJQ5YN910kxISElSjRg1NnTpVlmXp+eef19NPP61mzZpp+/btatCggcFSAQAA3EOpftlz06ZN9dlnn+mXX37RoUOHlJubq/DwcPsvebYsSzabzUihAAAA7qJUDxrNU61aNbVp00bt2rVTYGCgLl++rNdee0033XSTieUBAADcSrHPYF2+fFmrV6/W4cOHVa1aNd1xxx0KDg6WJGVmZuqVV17R3Llzdfr0aUVERBgvGAAAwNUVK2D99NNP6ty5sw4fPmx/crufn59Wr14tb29vDRw4UCdPnlTbtm01b9483XXXXWVSNAAAgCsrVsD6f//v/yk5OVkTJkxQdHS0kpOTNWvWLD3yyCM6c+aMmjZtqrffflu33XZbWdULAADg8ooVsOLj4zV06FDFxcXZx2rXrq17771XvXr10scffywPDyO3dQEAALitYqWhlJQU3XrrrQ5jedsPPfQQ4QoAAEDFDFg5OTny9fV1GMvbrlKlirmqAAAA3FixP0V49OhR7d27176dlpYmSfrhhx9UtWrVfPNbtWpV8uoAAADcULED1tSpUzV16tR84yNHjnTYznvIaE5OTsmrAwAAcEPFCliLFy8uqzoAAADKjWIFrCFDhpRVHQAAAOUGH/sDAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwzCUD1vz589WgQQP5+vqqXbt22rlzZ6Fzs7OzNWvWLEVERMjX11eRkZFav369w5ycnBxNnTpVYWFh8vPzU0REhP71r3/JsqyybgUAAFyHXC5grVixQuPHj9f06dO1d+9eRUZGKjY2VqmpqQXOnzJlihYtWqR58+bpu+++0/Dhw9WvXz/t27fPPufZZ5/VggUL9Morr+j777/Xs88+q+eee07z5s37s9oCAADXEZcLWHPmzNGwYcM0dOhQNWnSRAsXLlTFihX15ptvFjj/rbfe0uTJk9WzZ0+Fh4drxIgR6tmzp2bPnm2f88UXX6hPnz7q1auXGjRooHvuuUfdu3e/5pkxAACAknKpgHX58mXt2bNHMTEx9jEPDw/FxMQoMTGxwH2ysrLk6+vrMObn56eEhAT7dvv27bVp0yb973//kyR99dVXSkhIUI8ePcqgCwAAcL2r4OwCfuvMmTPKyclRUFCQw3hQUJAOHDhQ4D6xsbGaM2eOOnXqpIiICG3atEkffvihcnJy7HMmTpyo9PR0NWrUSJ6ensrJydFTTz2lQYMGFVpLVlaWsrKy7Nvp6emSrt7zlZ2dXZo27fLWMbWeK6An90BPrq+89SPRk7soi57K0/tTVC4VsEripZde0rBhw9SoUSPZbDZFRERo6NChDpcUV65cqWXLlmn58uVq2rSpkpKSNHbsWAUHB2vIkCEFrhsXF6eZM2fmG9+4caMqVqxotIf4+Hij67kCenIP9OT6yls/Ej25C5M9ZWZmGlvLXdgsF/oo3eXLl1WxYkW9//776tu3r318yJAh+vXXX/Xxxx8Xuu+lS5d09uxZBQcHa+LEifr000/17bffSpLq1auniRMnatSoUfb5Tz75pN5+++1Cz4wVdAarXr16OnPmjAICAkrZ6VXZ2dmKj49Xt27d5OXlZWRNZ6Mn90BPrq+89SPRk7soi57S09NVs2ZNpaWlGfs31NW51Bksb29v3XLLLdq0aZM9YOXm5mrTpk0aPXr0Nff19fVV3bp1lZ2drQ8++ED9+/e3v5aZmSkPD8fbzTw9PZWbm1voej4+PvLx8ck37uXlZfyHqCzWdDZ6cg/05PrKWz8SPbkLkz2Vt/emKFwqYEnS+PHjNWTIELVu3Vpt27bV3LlzlZGRoaFDh0qSBg8erLp16youLk6StGPHDp08eVItWrTQyZMnNWPGDOXm5mrChAn2NXv37q2nnnpK9evXV9OmTbVv3z7NmTNHDz30kFN6BAAA5ZvLBawBAwbo559/1rRp03T69Gm1aNFC69evt9/4fuzYMYezUZcuXdKUKVN05MgRVa5cWT179tRbb72lqlWr2ufMmzdPU6dO1ciRI5Wamqrg4GD9/e9/17Rp0/7s9gAAwHXA5QKWJI0ePbrQS4Jbtmxx2L7tttv03XffXXM9f39/zZ07V3PnzjVUIQAAQOFc6jlYAAAA5QEBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYJhLBqz58+erQYMG8vX1Vbt27bRz585C52ZnZ2vWrFmKiIiQr6+vIiMjtX79+nzzTp48qfvvv181atSQn5+fmjVrpt27d5dlGwAA4DrlcgFrxYoVGj9+vKZPn669e/cqMjJSsbGxSk1NLXD+lClTtGjRIs2bN0/fffedhg8frn79+mnfvn32Ob/88os6dOggLy8vrVu3Tt99951mz56tatWq/VltAQCA64jLBaw5c+Zo2LBhGjp0qJo0aaKFCxeqYsWKevPNNwuc/9Zbb2ny5Mnq2bOnwsPDNWLECPXs2VOzZ8+2z3n22WdVr149LV68WG3btlVYWJi6d++uiIiIP6stAABwHXGpgHX58mXt2bNHMTEx9jEPDw/FxMQoMTGxwH2ysrLk6+vrMObn56eEhAT79urVq9W6dWvde++9qlWrllq2bKnXX3+9bJoAAADXvQrOLuC3zpw5o5ycHAUFBTmMBwUF6cCBAwXuExsbqzlz5qhTp06KiIjQpk2b9OGHHyonJ8c+58iRI1qwYIHGjx+vyZMna9euXRozZoy8vb01ZMiQAtfNyspSVlaWfTs9PV3S1Xu+srOzS9uqfa3f/rc8oCf3QE+ur7z1I9GTuyiLnsrT+1NUNsuyLGcXkeenn35S3bp19cUXXygqKso+PmHCBG3dulU7duzIt8/PP/+sYcOG6ZNPPpHNZlNERIRiYmL05ptv6uLFi5Ikb29vtW7dWl988YV9vzFjxmjXrl2FnhmbMWOGZs6cmW98+fLlqlixYmlbBQDgupGZmamBAwcqLS1NAQEBzi7nT+FSZ7Bq1qwpT09PpaSkOIynpKSodu3aBe4TGBioVatW6dKlSzp79qyCg4M1ceJEhYeH2+fUqVNHTZo0cdivcePG+uCDDwqtZdKkSRo/frx9Oz09XfXq1VP37t2N/eXIzs5WfHy8unXrJi8vLyNrOhs9uQd6cn3lrR+JntxFWfSUdxXoeuJSAcvb21u33HKLNm3apL59+0qScnNztWnTJo0ePfqa+/r6+qpu3brKzs7WBx98oP79+9tf69Chgw4ePOgw/3//+59CQ0MLXc/Hx0c+Pj75xr28vIz/EJXFms5GT+6BnlxfeetHoid3YbKn8vbeFIVLBSxJGj9+vIYMGaLWrVurbdu2mjt3rjIyMjR06FBJ0uDBg1W3bl3FxcVJknbs2KGTJ0+qRYsWOnnypGbMmKHc3FxNmDDBvua4cePUvn17Pf300+rfv7927typ1157Ta+99ppTegQAAOWbywWsAQMG6Oeff9a0adN0+vRptWjRQuvXr7ff+H7s2DF5ePzfhx8vXbqkKVOm6MiRI6pcubJ69uypt956S1WrVrXPadOmjT766CNNmjRJs2bNUlhYmObOnatBgwb92e0BAIDrgMsFLEkaPXp0oZcEt2zZ4rB922236bvvvvvDNe+44w7dcccdJsoDAAC4Jpd6DhYAAEB5QMACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADKvg7ALchWVZkqT09HRja2ZnZyszM1Pp6eny8vIytq4z0ZN7oCfXV976kejJXZRFT3n/dub9W3o9IGAV0fnz5yVJ9erVc3IlAAC4p/Pnz6tKlSrOLuNPYbOupzhZCrm5ufrpp5/k7+8vm81mZM309HTVq1dPx48fV0BAgJE1nY2e3AM9ub7y1o9ET+6iLHqyLEvnz59XcHCwPDyuj7uTOINVRB4eHgoJCSmTtQMCAsrND2YeenIP9OT6yls/Ej25C9M9XS9nrvJcHzESAADgT0TAAgAAMIyA5UQ+Pj6aPn26fHx8nF2KMfTkHujJ9ZW3fiR6chflsSdn4CZ3AAAAwziDBQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWE40f/58NWjQQL6+vmrXrp127tzp7JJKbMaMGbLZbA5fjRo1cnZZxbJt2zb17t1bwcHBstlsWrVqlcPrlmVp2rRpqlOnjvz8/BQTE6MffvjBOcUWwR/18+CDD+Y7Zn/5y1+cU2wRxcXFqU2bNvL391etWrXUt29fHTx40GHOpUuXNGrUKNWoUUOVK1fW3XffrZSUFCdV/MeK0lPnzp3zHavhw4c7qeJrW7BggZo3b25/SGVUVJTWrVtnf93djo/0xz250/EpzDPPPCObzaaxY8fax9zxWLkSApaTrFixQuPHj9f06dO1d+9eRUZGKjY2Vqmpqc4urcSaNm2qU6dO2b8SEhKcXVKxZGRkKDIyUvPnzy/w9eeee04vv/yyFi5cqB07dqhSpUqKjY3VpUuX/uRKi+aP+pGkv/zlLw7H7J133vkTKyy+rVu3atSoUfryyy8VHx+v7Oxsde/eXRkZGfY548aN0yeffKL33ntPW7du1U8//aS77rrLiVVfW1F6kqRhw4Y5HKvnnnvOSRVfW0hIiJ555hnt2bNHu3fv1u23364+ffro22+/leR+x0f6454k9zk+Bdm1a5cWLVqk5s2bO4y747FyKRacom3bttaoUaPs2zk5OVZwcLAVFxfnxKpKbvr06VZkZKSzyzBGkvXRRx/Zt3Nzc63atWtbzz//vH3s119/tXx8fKx33nnHCRUWz+/7sSzLGjJkiNWnTx+n1GNKamqqJcnaunWrZVlXj4mXl5f13nvv2ed8//33liQrMTHRWWUWy+97sizLuu2226zHHnvMeUWVUrVq1aw33nijXByfPHk9WZZ7H5/z589bN9xwgxUfH+/QR3k6Vs7CGSwnuHz5svbs2aOYmBj7mIeHh2JiYpSYmOjEykrnhx9+UHBwsMLDwzVo0CAdO3bM2SUZk5ycrNOnTzscsypVqqhdu3Zufcy2bNmiWrVq6aabbtKIESN09uxZZ5dULGlpaZKk6tWrS5L27Nmj7Oxsh+PUqFEj1a9f322O0+97yrNs2TLVrFlTN998syZNmqTMzExnlFcsOTk5evfdd5WRkaGoqKhycXx+31Medzw+kjRq1Cj16tXL4ZhI5eNnydn4Zc9OcObMGeXk5CgoKMhhPCgoSAcOHHBSVaXTrl07LVmyRDfddJNOnTqlmTNnKjo6Wt988438/f2dXV6pnT59WpIKPGZ5r7mbv/zlL7rrrrsUFhamw4cPa/LkyerRo4cSExPl6enp7PL+UG5ursaOHasOHTro5ptvlnT1OHl7e6tq1aoOc93lOBXUkyQNHDhQoaGhCg4O1tdff60nnnhCBw8e1IcffujEagu3f/9+RUVF6dKlS6pcubI++ugjNWnSRElJSW57fArrSXK/45Pn3Xff1d69e7Vr1658r7n7z5IrIGDBiB49etj/3Lx5c7Vr106hoaFauXKl/va3vzmxMhTmr3/9q/3PzZo1U/PmzRUREaEtW7aoa9euTqysaEaNGqVvvvnG7e71u5bCenrkkUfsf27WrJnq1Kmjrl276vDhw4qIiPizy/xDN910k5KSkpSWlqb3339fQ4YM0datW51dVqkU1lOTJk3c7vhI0vHjx/XYY48pPj5evr6+zi6nXOISoRPUrFlTnp6e+T6NkZKSotq1azupKrOqVq2qG2+8UYcOHXJ2KUbkHZfyfMzCw8NVs2ZNtzhmo0eP1qeffqrPP/9cISEh9vHatWvr8uXL+vXXXx3mu8NxKqyngrRr106SXPZYeXt7q2HDhrrlllsUFxenyMhIvfTSS259fArrqSCufnykq5cAU1NT1apVK1WoUEEVKlTQ1q1b9fLLL6tChQoKCgpy22PlKghYTuDt7a1bbrlFmzZtso/l5uZq06ZNDtf03dmFCxd0+PBh1alTx9mlGBEWFqbatWs7HLP09HTt2LGj3ByzEydO6OzZsy59zCzL0ujRo/XRRx9p8+bNCgsLc3j9lltukZeXl8NxOnjwoI4dO+ayx+mPeipIUlKSJLn0sfqt3NxcZWVlueXxKUxeTwVxh+PTtWtX7d+/X0lJSfav1q1ba9CgQfY/l5dj5TTOvsv+evXuu+9aPj4+1pIlS6zvvvvOeuSRR6yqVatap0+fdnZpJfKPf/zD2rJli5WcnGz997//tWJiYqyaNWtaqampzi6tyM6fP2/t27fP2rdvnyXJmjNnjrVv3z7rxx9/tCzLsp555hmratWq1scff2x9/fXXVp8+faywsDDr4sWLTq68YNfq5/z589bjjz9uJSYmWsnJydZnn31mtWrVyrrhhhusS5cuObv0Qo0YMcKqUqWKtWXLFuvUqVP2r8zMTPuc4cOHW/Xr17c2b95s7d6924qKirKioqKcWPW1/VFPhw4dsmbNmmXt3r3bSk5Otj7++GMrPDzc6tSpk5MrL9jEiROtrVu3WsnJydbXX39tTZw40bLZbNbGjRsty3K/42NZ1+7J3Y7Ptfz+05DueKxcCQHLiebNm2fVr1/f8vb2ttq2bWt9+eWXzi6pxAYMGGDVqVPH8vb2turWrWsNGDDAOnTokLPLKpbPP//ckpTva8iQIZZlXX1Uw9SpU62goCDLx8fH6tq1q3Xw4EHnFn0N1+onMzPT6t69uxUYGGh5eXlZoaGh1rBhw1w+4BfUjyRr8eLF9jkXL160Ro4caVWrVs2qWLGi1a9fP+vUqVPOK/oP/FFPx44dszp16mRVr17d8vHxsRo2bGj985//tNLS0pxbeCEeeughKzQ01PL29rYCAwOtrl272sOVZbnf8bGsa/fkbsfnWn4fsNzxWLkSm2VZ1p93vgwAAKD84x4sAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELABlZsmSJbLZbIV+ffnll84uEQDKRAVnFwCg/Js1a1aBv8S4YcOGTqgGAMoeAQtAmevRo4dat27t1BoyMjJUqVIlp9YA4PrBJUIATnX06FHZbDa98MILeu211xQRESEfHx+1adNGu3btyjf/wIEDuueee1S9enX5+vqqdevWWr16tcOcvEuTW7du1ciRI1WrVi2FhITYX58/f77Cw8Pl5+entm3bavv27ercubM6d+4sSbpw4YIqVaqkxx57LN/3P3HihDw9PRUXF2f2jQBQrnAGC0CZS0tL05kzZxzGbDabatSoYd9evny5zp8/r7///e+y2Wx67rnndNddd+nIkSPy8vKSJH377bfq0KGD6tatq4kTJ6pSpUpauXKl+vbtqw8++ED9+vVz+B4jR45UYGCgpk2bpoyMDEnSggULNHr0aEVHR2vcuHE6evSo+vbtq2rVqtlDWOXKldWvXz+tWLFCc+bMkaenp33Nd955R5ZladCgQWXyXgEoJywAKCOLFy+2JBX45ePjY1mWZSUnJ1uSrBo1aljnzp2z7/vxxx9bkqxPPvnEPta1a1erWbNm1qVLl+xjubm5Vvv27a0bbrgh3/ft2LGjdeXKFft4VlaWVaNGDatNmzZWdna2fXzJkiWWJOu2226zj23YsMGSZK1bt86hp+bNmzvMA4CCcIkQQJmbP3++4uPjHb7WrVvnMGfAgAGqVq2afTs6OlqSdOTIEUnSuXPntHnzZvXv31/nz5/XmTNndObMGZ09e1axsbH64YcfdPLkSYc1hw0b5nD2affu3Tp79qyGDRumChX+7wT+oEGDHL63JMXExCg4OFjLli2zj33zzTf6+uuvdf/995fyHQFQ3nGJEECZa9u27R/e5F6/fn2H7bzA88svv0iSDh06JMuyNHXqVE2dOrXANVJTU1W3bl379u8/ufjjjz9Kyv/pxQoVKqhBgwYOYx4eHho0aJAWLFigzMxMVaxYUcuWLZOvr6/uvffea/YCAAQsAC7ht2eafsuyLElSbm6uJOnxxx9XbGxsgXN/H5z8/PxKVdPgwYP1/PPPa9WqVbrvvvu0fPly3XHHHapSpUqp1gVQ/hGwALiF8PBwSZKXl5diYmJKtEZoaKikq2fDunTpYh+/cuWKjh49qubNmzvMv/nmm9WyZUstW7ZMISEhOnbsmObNm1fCDgBcT7gHC4BbqFWrljp37qxFixbp1KlT+V7/+eef/3CN1q1bq0aNGnr99dd15coV+/iyZcvslyJ/74EHHtDGjRs1d+5c1ahRQz169Ch5EwCuG5zBAlDm1q1bpwMHDuQbb9++vTw8iv7/efPnz1fHjh3VrFkzDRs2TOHh4UpJSVFiYqJOnDihr7766pr7e3t7a8aMGXr00Ud1++23q3///jp69KiWLFmiiIgI2Wy2fPsMHDhQEyZM0EcffaQRI0bYHxkBANdCwAJQ5qZNm1bg+OLFi+0P9yyKJk2aaPfu3Zo5c6aWLFmis2fPqlatWmrZsmWh3+P3Ro8eLcuyNHv2bD3++OOKjIzU6tWrNWbMGPn6+uabHxQUpO7du2vt2rV64IEHilwrgOubzcq7gxQArlO5ubkKDAzUXXfdpddffz3f6/369dP+/ft16NAhJ1QHwB1xDxaA68qlS5f0+/+v/M9//qNz584VeDbt1KlTWrNmDWevABQLZ7AAXFe2bNmicePG6d5771WNGjW0d+9e/fvf/1bjxo21Z88eeXt7S5KSk5P13//+V2+88YZ27dqlw4cPq3bt2k6uHoC74B4sANeVBg0aqF69enr55Zd17tw5Va9eXYMHD9YzzzxjD1eStHXrVg0dOlT169fX0qVLCVcAioUzWAAAAIZxDxYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMP+P+3fHVhEceObAAAAAElFTkSuQmCC",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAlgAAAJYCAYAAAC+ZpjcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABm6UlEQVR4nO3dd3hTZf/H8U+atukeUPZesmUoU5ayxY2IojJUUJyAg6FsEXhExYGb5UBxIKIiCigPw4qKoKCIbBDZtOlu0+b+/dGH/KysFpJm9P26Li7NycnJ95vTNJ+e3Oc+FmOMEQAAANwmyNsFAAAABBoCFgAAgJsRsAAAANyMgAUAAOBmBCwAAAA3I2ABAAC4GQELAADAzQhYAAAAbkbAAgAAcDMCFgAAgJsRsAAAANyMgAUAAOBmBCwAAAA3I2ABAAC4GQELAADAzQhYAAAAbkbAAgAAcDMCFgAAgJsRsAAAANyMgAUAAOBmBCwAAAA3I2ABAAC4GQELAADAzQhYAAAAbkbAAgAAcDMCFgAAgJsRsAAAANyMgAUAAOBmBCwAAAA3I2ABAAC4GQELAADAzQhYAAAAbkbAAgAAcDMCFgAAgJsRsAAAANyMgAUAAOBmBCwAAAA3I2ABAAC4GQELAADAzQhYAAAAbkbAAgAAcDMCFgAAgJsRsAAAANyMgAUAAOBmBCwAAAA3I2ABAAC4GQELAADAzQhYAAAAbkbAAgAAcDMCFgBVr15dAwcOPO/HXnXVVe4tyM9ZLBZNmDChSI9JS0vTXXfdpfLly8tisWjYsGEeqQ1A8SBgAQFs8+bNuvHGG1WtWjWFhYWpUqVK6tq1q1588UVvl4Z/eeqppzRv3jwNHTpUb7/9tm6//XZvlwTgAgR7uwAAnvHdd9/p8ssvV9WqVTV48GCVL19e+/fv1/fff6/nn39eDzzwgGvdbdu2KSiIv7e86ZtvvlHr1q01fvx4b5cCwA0IWECAmjJlimJjY/Xjjz8qLi6uwH1HjhwpcNtmsxVjZWeXm5srp9Op0NBQb5dyRunp6YqMjHTrNo8cOaIGDRq4dZsAvIc/WYEAtXPnTjVs2PCUcCVJZcuWLXD732Ow5s2bJ4vFonXr1mnEiBEqU6aMIiMjdf311+vo0aOnfb61a9eqZcuWCgsLU82aNfXWW2+ds8Y9e/bIYrFoxowZmjlzpmrVqiWbzabff/9dkvTHH3/oxhtvVKlSpRQWFqZLL71US5YscT0+OTlZVqtVL7zwgmvZsWPHFBQUpNKlS8sY41o+dOhQlS9f3nV7zZo16tOnj6pWrSqbzaYqVapo+PDhyszMLFDjwIEDFRUVpZ07d+rKK69UdHS0br31VklSdna2hg8frjJlyig6OlrXXHON/vrrr3P2/U+rVq2SxWLR7t279cUXX8hischisWjPnj2u+z744ANNmTJFlStXVlhYmDp37qwdO3YU6XkAFC8CFhCgqlWrpg0bNmjLli3nvY0HHnhAv/zyi8aPH6+hQ4fqs88+0/3333/Kejt27NCNN96orl276plnnlF8fLwGDhyo3377rVDPM3fuXL344osaMmSInnnmGZUqVUq//fabWrdura1bt2rUqFF65plnFBkZqeuuu06ffPKJJCkuLk6NGjXS6tWrXdtau3atLBaLTpw44QpqUn6gat++vev2hx9+qIyMDA0dOlQvvviiunfvrhdffFH9+/c/pb7c3Fx1795dZcuW1YwZM9S7d29J0l133aWZM2eqW7dumjZtmkJCQtSrV6/Cvbj/U79+fb399ttKSEhQ06ZN9fbbb+vtt99WmTJlXOtMmzZNn3zyiR555BGNHj1a33//vSvkAfBRBkBA+vrrr43VajVWq9W0adPGPPbYY+arr74yOTk5p6xbrVo1M2DAANftuXPnGkmmS5cuxul0upYPHz7cWK1Wk5ycXOCxkszq1atdy44cOWJsNpt5+OGHz1rj7t27jSQTExNjjhw5UuC+zp07m8aNG5usrCzXMqfTadq2bWvq1KnjWnbfffeZcuXKuW6PGDHCdOjQwZQtW9a88sorxhhjjh8/biwWi3n++edd62VkZJxSz9SpU43FYjF79+51LRswYICRZEaNGlVg3U2bNhlJ5t577y2wvF+/fkaSGT9+/Fl7/7dq1aqZXr16FVj27bffGkmmfv36Jjs727X8+eefN5LM5s2bi/QcAIoPR7CAANW1a1clJibqmmuu0S+//KL//Oc/6t69uypVqlTga7azGTJkiCwWi+t2+/btlZeXp7179xZYr0GDBgWODpUpU0Z169bVrl27CvU8vXv3LnDE5sSJE/rmm2900003KTU1VceOHdOxY8d0/Phxde/eXdu3b9eBAwdcNR0+fFjbtm2TlH+kqkOHDmrfvr3WrFkjKf+oljGmQI3h4eGu/09PT9exY8fUtm1bGWO0cePGU2ocOnRogdtLly6VJD344IMFlntieoVBgwYVGJN2so/Cvr4Aih8BCwhgLVq00KJFi5SUlKQffvhBo0ePVmpqqm688cYCX5+dSdWqVQvcjo+PlyQlJSWddb2T6/57vTOpUaNGgds7duyQMUZjx45VmTJlCvw7eZbdyYH6J8PGmjVrlJ6ero0bN6p9+/bq0KGDK2CtWbNGMTExatKkies59u3bp4EDB6pUqVKKiopSmTJl1LFjR0mS3W4vUE9wcLAqV65cYNnevXsVFBSkWrVqFVhet27dQvVcFIXdDwB8B2cRAiVAaGioWrRooRYtWuiiiy7SoEGD9OGHH55zSgCr1Xra5eYfg8eLst6Z/PNokiQ5nU5J0iOPPKLu3buf9jG1a9eWJFWsWFE1atTQ6tWrVb16dRlj1KZNG5UpU0YPPfSQ9u7dqzVr1qht27auqSjy8vLUtWtXnThxQiNHjlS9evUUGRmpAwcOaODAga7nP8lms3l1GosLfX0BFD8CFlDCXHrppZKkgwcPermSM6tZs6YkKSQkRF26dDnn+u3bt9fq1atVo0YNNW3aVNHR0WrSpIliY2O1bNky/fzzz5o4caJr/c2bN+vPP//U/PnzCwxqX758eaFrrFatmpxOp3bu3FngqNXJryoBlGx8RQgEqG+//fa0RzhOjh3yxFdZ7lK2bFl16tRJr7322mmD4L+nimjfvr327NmjhQsXur4yDAoKUtu2bfXss8/K4XAUGH918ojQP18fY4yef/75QtfYs2dPSSowRYQkzZw5s9DbABC4OIIFBKgHHnhAGRkZuv7661WvXj3l5OTou+++08KFC1W9enUNGjTI2yWe1axZs9SuXTs1btxYgwcPVs2aNXX48GElJibqr7/+0i+//OJa92R42rZtm5566inX8g4dOujLL7+UzWZTixYtXMvr1aunWrVq6ZFHHtGBAwcUExOjjz/+uEhjmpo2bapbbrlFL7/8sux2u9q2bauVK1cyPxUASQQsIGDNmDFDH374oZYuXarXX39dOTk5qlq1qu6991498cQTp52A1Jc0aNBAP/30kyZOnKh58+bp+PHjKlu2rJo1a6Zx48YVWLdu3boqW7asjhw5onbt2rmWnwxeLVu2LDBbfUhIiD777DM9+OCDmjp1qsLCwnT99dfr/vvvLzAQ/lzmzJmjMmXK6N1339XixYt1xRVX6IsvvlCVKlUusHsA/s5iGCUJAADgVozBAgAAcDO+IgQAD8nLyzvjtRtPioqKUlRUVDFVBKC4ELAAwEP2799/yiSq/zZ+/HhNmDCheAoCUGwIWADgIeXLlz/n3Fon5/wCEFgY5A4AAOBmDHIHAABwM74iLCSn06m///5b0dHRslgs3i4HAAC/YYxRamqqKlas6NXrehYnAlYh/f3330weCADABdi/f78qV67s7TKKBQGrkKKjoyXl/3DExMS4ZZsOh0Nff/21unXrppCQELds09voyT/Qk+8LtH4kevIXnugpJSVFVapUcX2WlgQErEI6+bVgTEyMWwNWRESEYmJiAuqNSU++j558X6D1I9GTv/BkTyVpiE3J+CIUAACgGBGwAAAA3IyABQAA4GYELAAAADcjYAEAALgZAQsAAMDNCFgAAABuRsACAABwMwIWAACAmxGwAAAA3IyABQAA4GYELAAAADcjYAEAALgZAQsAAMDNCFgAAABuRsACAABwMwIWAABw+evPXDnzLN4uw+8RsAAAgCTpxKE8vTY8RT+/01CpJ5zeLsevEbAAAICcTqP3ptiVnWEUFOxURCxHsS4EAQsAAGj1hxnasTFHoWFSvSt3ymolYF2IYG8XAAAAvOvgLoe+eC1VknTV0EidCM72ckX+jyNYAACUYLkOo3eftCs3R6rfxqZWV9u8XVJAIGABAFCCfT03TQf+zFVEjEV9R8bIYuGrQXcgYAEAUELt2ZKjFe+kS5L6PBKr2ASrlysKHAQsAABKoKx0p96eaJdxSpd0C1PTK8K8XVJAIWABAFACLZqZohMH8xRfPki9h8d4u5yAQ8ACAKCE2bgyUz9+mSVLkHTr2DiFRxMH3M0vX9HVq1fr6quvVsWKFWWxWLR48eKzrr9q1SpZLJZT/h06dKh4CgYAwEckHc7Th0+nSJK63B6pWk1CvVxRYPLLgJWenq4mTZpo1qxZRXrctm3bdPDgQde/smXLeqhCAAB8jzPP6N3JycpMM6paP0TdB0V5u6SA5ZcTjfbs2VM9e/Ys8uPKli2ruLg49xcEAIAf+Pa9dO3c5FBouEW3jY+VNZgpGTzFLwPW+WratKmys7PVqFEjTZgwQZdddtkZ183OzlZ29v/PZJuSkn841eFwyOFwuKWek9tx1/Z8AT35B3ryfYHWj0RP3vbXtlwtfSNNknTtAxGKK2dOW7cnevKH18fdLMYY4+0iLoTFYtEnn3yi66677ozrbNu2TatWrdKll16q7Oxsvfnmm3r77be1fv16NW/e/LSPmTBhgiZOnHjK8gULFigiIsJd5QMA4HF5OUH66a1GykwKV5mLjqvBNTtUnPOJZmRkqF+/frLb7YqJKRlnLJaIgHU6HTt2VNWqVfX222+f9v7THcGqUqWKjh075rYfDofDoeXLl6tr164KCQlxyza9jZ78Az35vkDrR6Inb/r4mTSt/zxbsQlBGj47VhExZx6C7YmeUlJSlJCQUKICVon6ivCfWrZsqbVr157xfpvNJpvt1OsxhYSEuP1N5Iltehs9+Qd68n2B1o9ET8Vt8+osrf88WxaLdOvYWMWWLty1Bt3Zk6++Np7kl2cRusOmTZtUoUIFb5cBAIDHJB/J08LpdklSp1siVecSLuRcXPzyCFZaWpp27Njhur17925t2rRJpUqVUtWqVTV69GgdOHBAb731liRp5syZqlGjhho2bKisrCy9+eab+uabb/T11197qwUAADwqL9fonUnJSrcbVb4oWFfexZQMxckvA9ZPP/2kyy+/3HV7xIgRkqQBAwZo3rx5OnjwoPbt2+e6PycnRw8//LAOHDigiIgIXXzxxVqxYkWBbQAAEEi+np+mnZscsoVb1H9inIJDmZKhOPllwOrUqZPONjZ/3rx5BW4/9thjeuyxxzxcFQAAvmH7z9laPi9dktTn0RiVqeKXH/d+rcSOwQIAIBClJuXpnYl2GSO16hWuS7qFe7ukEomABQBAgHA6jd6bYlfKcafKVbfq+mHR3i6pxCJgAQAQIP77foa2fp+jkFBpwKQ42cL5mPcWXnkAAALA3t9y9PlrqZKk6x6KUYWaJW/uKV9CwAIAwM9lpjr11gS7nHlS0yvC1OYaxl15GwELAAA/ZozRwul2nTiYp9IVrbrpsRhZivNCgzgtAhYAAH7su08z9cuqbFmDpf4T4xQexUe7L2AvAADgp/b/4dAnz6dIkq66J1pV6zPuylcQsAAA8EMZKU7NG5usPIfUuL1NHftGeLsk/AMBCwAAP+N0Gr375P+Pu7plTCzjrnwMAQsAAD/z7YJ0/f5dtoJDpYFPxik8mo9zX8MeAQDAj+z4OVtfvJ4mSbphWIwqX8S4K19EwAIAwE/Yj+XprQl2Gad0aY8wtb6a+a58FQELAAA/kJdr9PaEZKWecKpCzWDd+DDzXfkyAhYAAH7gyzfTtHOTQ7ZwiwY+yXUGfR17BwAAH/fbuiytfCddktR3VIzKVg32ckU4FwIWAAA+7NiBXL072S5Jan9jhJp1ZtyVPyBgAQDgo3KyjOY+nqzMNKNqDUJ0zX3R3i4JhUTAAgDAB528iPPfO3IVFR+kgU/GKTiEQe3+goAFAIAPWv1hhn5enqUgqzRgUpziylq9XRKKgIAFAICP2fFztpbMSpUkXXNftGo3C/VyRSgqAhYAAD4k6XCe5o+zy5knXdI9TB36cBFnf0TAAgDARziyjeY+nqS0ZKcq1QnWTY9yEWd/RcACAMAHGGP08bMp2v9HriJiLLrjqTiFhhGu/BUBCwAAH/Ddp5la/0WmLEFS/4lxKlWByUT9GQELAAAv27MlR5/MTJEk9RoSpbotbF6uCBeKgAUAgBclH83T3MeTlZcrNelk0xW3Rnq7JLgBAQsAAC/JyTaaMzpJKcedqlAzWDePYVB7oCBgAQDgBcYYLZxq1/4/chUZa9Gd0+IUFsHHcqBgTwIA4AUr30nXzyvyZ2ofODlOpSsyqD2QELAAAChmW9ZmaenraZKkG4bHqHZzBrUHGgIWAADF6OAuh96ZaJcx0mXXR+iy65ipPRARsAAAKCbpdqfeHJms7Eyj2s1Ddf1D0d4uCR5CwAIAoBjk5RrNeyJZJw7mqVQFqwZOjpM1mDMGAxUBCwCAYvDJ86nasTFHtnCL7poep8hYPoIDGXsXAAAPW7c4Q+s+yZDFIt02PlYVaoZ4uyR4GAELAAAP2vZjthY9l38ZnCuHRKlRuzAvV4TiQMACAMBDDu3O1byxyXLmSZd0D1Pn27gMTklBwAIAwANSk/L0xmNJykozqnFxiG4eyWVwShICFgAAbpaTbTR7VP4ZgwmVrLrjqXgFhxKuShICFgAAbuR0Gr3/lF17f3MoItqiwU/HKyqOj9uShj0OAIAbLZudpo0rs2QNlgZNiVPZqlxjsCQiYAEA4CY/fpmp5fPTJUk3PcY1BksyAhYAAG6wc1OOFk63S5K63B6plldyjcGSjOOWAABcoKN/5WnOGLvycqUml4ep5+Aob5cEL+MIFgAAFyAnI1hzRqUoI8WoWoMQ9XsiVkFBnDFY0nEECwCA85STZbRl0UVKOehUqQpW3TktTqE2whU4ggUAwHlx5hm992SqUg5GKyLGorufiVd0Kau3y4KPIGABAFBExhgtei5Fv61zyGJ1auCT0UzHgAIIWAAAFNHKd9K1bnGmLBapQa8dqt44xNslwccQtwEAKIKfvsrUF6+lSZKuvi9CKeFJXq4IvogjWAAAFNKfP2Xr/an5c111ujlC7XqHe7ki+CoCFgAAhfD3DofmPp6svFypWecwXX1vtLdLgg8jYAEAcA5Jh/P0+iNJyko3qtU0RP0eZ64rnJ1fBqzVq1fr6quvVsWKFWWxWLR48eJzPmbVqlVq3ry5bDabateurXnz5nm8TgCA/8tMder1R5JkP+ZUuerBuuOpeAWHEq5wdn4ZsNLT09WkSRPNmjWrUOvv3r1bvXr10uWXX65NmzZp2LBhuuuuu/TVV195uFIAgD/LyTJ6Y2SSDu3OVUzpIN09I14RMX750Yli5pdnEfbs2VM9e/Ys9PqvvvqqatSooWeeeUaSVL9+fa1du1bPPfecunfv7qkyAQB+LC/XaP64ZO3+1aGwKIuGzIhXfHkmEkXhlIgYnpiYqC5duhRY1r17dyUmJnqpIgCAL3M6jRZOt+v377IVEirdNT1eleow1xUKzy+PYBXVoUOHVK5cuQLLypUrp5SUFGVmZio8/NTTbLOzs5Wdne26nZKSIklyOBxyOBxuqevkdty1PV9AT/6BnnxfoPUj+VdPn7+arh+/zFJQkHTr+GhVbWA5bd3+1FNheaKnQHp9CqtEBKzzMXXqVE2cOPGU5V9//bUiIiLc+lzLly936/Z8AT35B3ryfYHWj+T7Pe1bX0G7VleVJF3Ufaf2JB/TnqVnf4yv93Q+3NlTRkaG27blL0pEwCpfvrwOHz5cYNnhw4cVExNz2qNXkjR69GiNGDHCdTslJUVVqlRRt27dFBMT45a6HA6Hli9frq5duyokJDAOPdOTf6An3xdo/Uj+0dOPS7O0anW6JKnXPRHq2LflWdf3h56KyhM9nfwWqCQpEQGrTZs2Wrq04J8fy5cvV5s2bc74GJvNJpvNdsrykJAQt7+JPLFNb6Mn/0BPvi/Q+pF8t6fNa7L00TP54eqKfpHqclvhJxL11Z4uhDt7CrTXpjD8cpB7WlqaNm3apE2bNknKn4Zh06ZN2rdvn6T8o0/9+/d3rX/PPfdo165deuyxx/THH3/o5Zdf1gcffKDhw4d7o3wAgI/ZuSlHb41PlnFKrXqF66qhUd4uCX7OLwPWTz/9pGbNmqlZs2aSpBEjRqhZs2YaN26cJOngwYOusCVJNWrU0BdffKHly5erSZMmeuaZZ/Tmm28yRQMAQAe2O/TmyCTl5kiN2tvU59EYWSxMJIoL45dfEXbq1EnGmDPef7pZ2jt16qSNGzd6sCoAgL85si9Xr474/0vg3D4hTtZgwhUunF8ewQIA4EKdOJirV4adUFqSU5UuCtad0+IVaiNcwT0IWACAEsd+LE+vDEtS8hGnylW36p5nSik8io9EuA8/TQCAEiUt2alXhiXp2IE8lapg1T3PlVJUPB+HcC9+ogAAJUZmmlOvjTihw3tyFVsmSPc+H6+4MlxfEO5HwAIAlAjZmU698WiS/vozV1FxQRo6s5RKV/TLc73gBwhYAICA58g2mjMmWbs3OxQeZdE9z8WrXDXCFTyHgAUACGh5uUZvTUjWnz/mKDTcoiEz4lWpTsmbWRzFi4AFAAhYzjyjBVPs2rImW8Gh0l3T4lS9Uai3y0IJQMACAAQkp9Powxkp+nl5loKs0sAn41TnklOvMQt4AgELABBwjDFa9GyKvv8sU5Yg6bZxsWrYNszbZaEEIWABAAKKMUafPJ+qdYszZbFI/R6PVbPO4d4uCyUMAQsAEDCMMfr0pVSt+ShDFot08+gYXdqdcIXiR8ACAAQEY4w+eyVN/12YIUm66bEYtbwywstVoaQiYAEA/J4xRktfT9O3C9IlSTc+EqPWVxOu4D0ELACA31s2J00r3s4PVzcMj9Zl1xGu4F0ELACAX/t6Xpq+npsfrq57MFrte0d6uSKAgAUA8GMr3k7Tl2+mSZKuuTdaHW8iXME3ELAAAH7pmwXp+uK1/HDV6+4oXd6PcAXfwZUuAQB+Z/lbaVr6en646nFnlLrcHuXlioCCCFgAAL/y1dw0LZudH6563hWlbgMJV/A9BCwAgF8wxmjZ7DR9PS9/QHuvuzlyBd9FwAIA+LyT81ydnIrhmnujGXMFn0bAAgD4tJMztJ+cRPS6BzlbEL6PgAUA8Fknry148vI3vYdHqx3zXMEPELAAAD7JGKNPns+/cLMk9XkkRm2ZoR1+goAFAPA5TqfRomdTtG5xpiwW6aaRMWp9FeEK/oOABQDwKc48ow9npOj7z/LD1c1jYtWyZ7i3ywKKhIAFAPAZeblGC6bY9fPyLFmCpH6Px+rS7oQr+B8CFgDAJ+TmGM0fn6wta7IVZJVuGxerZp0JV/BPBCwAgNdlZzo1Z0yy/vwxR8Gh0sAn49SwbZi3ywLOGwELAOBVmWlOvfFYknb/6lBouEV3TYtTnUts3i4LuCAELACA16TbnXp1xAn9tS1XYVEW3T0jXtUbhXq7LOCCEbAAAF6RcjxPrw5P0sFduYqMs+ieZ0up8kUh3i4LcAsCFgCg2J04lKdXhp3Qsb/yFJsQpKEzS6lcdT6SEDj4aQYAFKujf+XpjYeTlHzEqVIVrBo6M14Jlfg4QmDhJxoAUGzSjobrlQftSksyKlvVqqEzSymurNXbZQFuR8ACABSLPVsc2vR+A+VmGVWsHax7notXdDzhCoGJgAUA8Litidma+0SKcrODVa1hsIY8XUoRMUHeLgvwGH66AQAe9fPyTL05KkmObKlUjWQNfjqGcIWAxxEsAIDHrPk4XZ/MTJUxUtMrQhXT9E+FhtfydlmAx/EnBADA7YwxWjY7VYueyw9X7XpH6ObHoxRkNd4uDSgWHMECALiV02n0ycxUrV2UIUnqcWeUug2MVG5urpcrA4oPAQsA4Da5DqMFT9q1cWWWLBbphuExandDhLfLAoodAQsA4BbZmU7NezxZf/yQoyCrdOvYWDXvEu7tsgCvIGABAC5YeopTbzyapL2/ORQaZtGgKXGq18rm7bIAryFgAQAuSNLhPL32cJIO78lVRLRFg5+OV/VGod4uC/AqAhYA4Lz9vdOh1x9Jkv2oU7FlgnT3M/GqUDPE22UBXkfAAgCcl+0/Z2vO6GRlpRuVqx6su5+JV3w5Ln0DSAQsAMB52LgyU+8+aVeeQ6rZJER3To1ndnbgHwhYAIAiWbUwXZ++mCpJatLJplvHxinEZvFyVYBvIWABAArF6TT6bFaqVi3Mn0C0/Y0Ruu6BaAVZCVfAvxGwAADnlJtjtGBK/gSiknT1vdG6/JYIWSyEK+B0CFgAgLPKTHNqzphk7fg5R9Zg6ZYxsbqkGxOIAmdDwAIAnFHy0Ty9/kiSDu7MlS0ifwLRui2YQBQ4FwIWAOC0Du7Kn+Mq+YhT0aWDdPeMeFWqwxxXQGH47Tm1s2bNUvXq1RUWFqZWrVrphx9+OOO68+bNk8ViKfAvLCysGKsFAP/y50/ZeuHeE0o+4lTZqlYNe7UU4QooAr8MWAsXLtSIESM0fvx4/fzzz2rSpIm6d++uI0eOnPExMTExOnjwoOvf3r17i7FiAPAfPyzN0GsPJykrzahmkxA9+EpplarAFx5AUfhlwHr22Wc1ePBgDRo0SA0aNNCrr76qiIgIzZkz54yPsVgsKl++vOtfuXLlirFiAPB9xhgtfSNV7z2VImee1LxLmIY+V0qRsX75UQF4ld/9SZKTk6MNGzZo9OjRrmVBQUHq0qWLEhMTz/i4tLQ0VatWTU6nU82bN9dTTz2lhg0bnnH97OxsZWdnu26npKRIkhwOhxwOhxs6kWs77tqeL6An/0BPvq+4+8nNMfrw6TRtXJEjSbritnB1GxQuY8mVu0oItH0k0VNRt1mSWIwxxttFFMXff/+tSpUq6bvvvlObNm1cyx977DH997//1fr16095TGJiorZv366LL75YdrtdM2bM0OrVq/Xbb7+pcuXKp32eCRMmaOLEiacsX7BggSIiItzXEAB4mSPTqi2LL5L9rxhZgpy6qNseVWh81NtlIYBkZGSoX79+stvtiomJ8XY5xaJEBKx/czgcql+/vm655RZNnjz5tOuc7ghWlSpVdOzYMbf9cDgcDi1fvlxdu3ZVSEhgDB6lJ/9AT76vuPo5fiBPc0an6Oh+p8IiLbp9YpTqXBLqkecKtH0k0VNhpaSkKCEhoUQFLL/7ijAhIUFWq1WHDx8usPzw4cMqX758obYREhKiZs2aaceOHWdcx2azyWY7da6XkJAQt7+JPLFNb6Mn/0BPvs+T/ezZkqM3R9mVnmwUVzZIQ2bEq0JNz792gbaPJHoqzLZKGr8buRgaGqpLLrlEK1eudC1zOp1auXJlgSNaZ5OXl6fNmzerQoUKnioTAHzapm+z9PKDJ5SebFT5omANe710sYQroKTwuyNYkjRixAgNGDBAl156qVq2bKmZM2cqPT1dgwYNkiT1799flSpV0tSpUyVJkyZNUuvWrVW7dm0lJyfr6aef1t69e3XXXXd5sw0AKHbGGH37XoY+ezlVktTwMptuHx8rW4Tf/b0N+DS/DFh9+/bV0aNHNW7cOB06dEhNmzbVsmXLXFMv7Nu3T0FB///LIikpSYMHD9ahQ4cUHx+vSy65RN99950aNGjgrRYAoNjl5Rp9/FyKEj/NlCS1vzFC1z0QrSArF2wG3M0vA5Yk3X///br//vtPe9+qVasK3H7uuef03HPPFUNVAOCbMlKcmjc2Wds35Mhika59IFodb4r0dllAwPLbgAUAKJyj+3P1xmNJOro/T6HhFt0+PlaN2nG5MMCTCFgAEMC2/5yteY8nKyM1/0zBu6ZzwWagOBCwACBAJS7J0EfP5F/2plrDEN3xVJxiSlu9XRZQIhCwACDAOPOMlrycqv8uzJCUf03Bm0fHKsTGYHaguBCwACCAZKU79fZEu37/Lv9KFD3vilLXAZGyWAhXQHEiYAFAgDhxMFdvjkzWwV25CgmVbnk8Vs06h3u7LKBEImABQADYvTlHc8YkKy3JqZjSQbpzWryq1mcwO+AtZ526d8mSJfr777+LqxYAwHnY8HWmZj14QmlJTlW6KFjD3yhNuAK87KwB6/rrry8waWfNmjW1ZMkST9cEACgEp9No6eupemeSXXkOqXF7mx6YVUpxZTlTEPC2s35FGB0dreTkZNftPXv2KC0tzdM1AQDOITvDqQVT7Pr1v/mD2TvfFqkrh0QpKIjB7IAvOGvAatmypaZMmaLDhw8rNjZWkrR06VIdOnTojI+xWCwaPny4e6sEALgc/ztXs0cn6+DOXFlDpJsei1XLngxmB3zJWQPWyy+/rP79+2vy5MmS8sPTggULtGDBgjM+hoAFAJ6z4+dszRubrHS7UXTpIN0xJU7VG4V6uywA/3LWgFW7dm199913ysrK0pEjR1S9enXNnDlT1157bXHVBwCQZIzRuk8y9cnz+TOzV6kXrDueime8FeCjCjVNQ1hYmKpWrarx48friiuuULVq1TxdFwDgf3IdRoueS1HikkxJ0iXdwnTTyFiFMjM74LOKNA/W+PHjXf9/8OBBHTlyRLVr11ZkZKTbCwMASGlJTr0z8YR2/eKQxSL1uidKV/RjZnbA1511mobT+fTTT1WvXj1VrlxZzZs31/r16yVJx44dU7NmzbR48WJ31wgAJVLq4Qi9MNSuXb84FBZp0V3/iVfnW6MIV4AfKFLA+uyzz3TDDTcoISFB48ePlzHGdV9CQoIqVaqkuXPnur1IAChpfl2VrY0LGij5sFNlqlg17PXSatDG5u2yABRSkQLWpEmT1KFDB61du1b33XffKfe3adNGGzdudFtxAFDSOJ1GS99I1TsT0+TMteqiFiEa/npplavGlc0Af1KkgLVlyxbddNNNZ7y/XLlyOnLkyAUXBQAlUVaGU3MfT9by+emSpMqXHtQdU6MVHl3k0RwAvKxIfxJFREQoPT39jPfv2rVLpUuXvuCiAKCkOXYgV7NHJevQ7lwFh0q9R0TpcN4+BVkbebs0AOehSH8WXX755Zo/f75yc3NPue/QoUN644031K1bN7cVBwAlwbYfs/XcXcd1aHeuYkoH6f6XSumS7oy3AvxZkY5gTZkyRa1bt1aLFi3Up08fWSwWffXVV/rmm2/02muvyRhTYCoHAMCZGWO06r0MffZqqoxTqlo/RHdMjVNsglUOh8Pb5QG4AEUKWHXr1tXatWv10EMPaezYsTLG6Omnn5YkderUSbNmzVL16tU9UScABJTsTKcWTkvRxpVZkqSWV4brxodjFMLkoUBAKPJpKQ0bNtSKFSuUlJSkHTt2yOl0qmbNmipTpown6gOAgHPsQK7mjMm/WHOQVbr+oRhddn0481sBAeS8z/uNj49XixYt3FkLAAS8P9Zn6+0JycpINYouFaSBk+NUswkXawYCTZEDVkpKip577jl98cUX2rt3rySpWrVquuqqqzRs2DDFxMS4vUgA8HfGGK18J11LX0+TMVK1BiEaOCVOcWW4WDMQiIoUsP7++2+1b99eu3fvVr169XTZZZdJkrZt26YJEyborbfe0po1a1ShQgWPFAsA/igrw6n3nrLr11XZkqTWV4er9/AYBYfylSAQqIoUsEaOHKlDhw7p888/15VXXlngvi+//FJ9+vTRqFGjNH/+fLcWCQD+6uj+XM0enazDe3JlDZZuGB6jttdGeLssAB5WpIC1bNkyDRs27JRwJUk9e/bUgw8+qDfeeMNtxQGAP/vtuyy9M8murDSjmNJBGjQlTtUbMd4KKAmKFLDS09NVrly5M95fvnz5s870DgAlgdNptOKtdC2bnT/eqkbjEA2YnD+/FYCSoUgzuTdo0EDvvfeecnJyTrnP4XDovffeU4MGDdxWHAD4m6z0/OsJfvlmfri67Lpw3ftCKcIVUMIUeQxW37591bJlS91777266KKLJOUPcn/11Vf166+/auHChR4pFAB83eG9uZozJklH9ubJGiLd+HCMWl/FeCugJCpSwOrTp4/S09M1atQo3XPPPa5J8YwxKlu2rObMmaMbb7zRI4UCgC/bsjZ/vFV2hlFsmfzxVtUaMN4KKKmKPA/WwIEDddttt+mnn34qMA/WpZdequDg8563FAD8ktNp9NXcNH09N3/8aa2mIRowKU7RpfhKECjJzisRBQcHq3Xr1mrdurW76wEAv5Ge4tQ7E5P1x/r8cantb4zQtfdHyxrM/FZASXfOQe4HDx5UvXr1NHbs2LOu98QTT6h+/fo6cuSI24oDAF+1f5tDz955XH+sz1FIqNTv8VjdMCyGcAVAUiEC1vPPP68TJ05o5MiRZ11v5MiROnHihF588UW3FQcAvmj95xl6YehxnTiYp9IVrXrotdJq0TPc22UB8CHnDFhffPGFbrnlFkVFRZ11vejoaPXr109LlixxW3EA4Esc2UYLp9v1/rQU5eZIDdraNOLN0qpUJ8TbpQHwMecMWDt37tTFF19cqI01bNhQO3bsuOCiAMDXnDiUpxfuPa7vP8uUxSJdOThKd06LU0RMkaYTBFBCnHOQu9VqPe3EoqfjcDgUFMQvGwCB5Y/12Xp7YrIyUowiYy26bXyc6rW0ebssAD7snGmoVq1aWrt2baE2tm7dOtWqVeuCiwIAX+B0Gn09L02vP5KkjBSjKvWCNWJ2AuEKwDmdM2Bdf/31+vDDD5WYmHjW9b7//nt98MEHuv76691WHAB4S0aKU7NH/f8lb9pcE64HZpVWqfLMbwXg3M4ZsEaMGKHKlSurW7dumj59ug4cOFDg/gMHDmj69Onq1q2bKleurOHDh3usWAAoDge2O/TsXcf1+3fZCg6Vbh4do5sei1WIjSkYABTOOcdgRUdHa8WKFbrhhhs0evRojRkzRrGxsYqOjlZqaqrsdruMMWrcuLEWLVqkmJiY4qgbADzixy8z9eHTdjlypFIVrBr4ZJyq1OUsQQBFU6iZ3GvWrKkNGzboo48+0pIlS/THH38oJSVFNWrUUL169XT11Vfrxhtv5FI5APxWbo7RJy+k6LvFmZKk+q1Ddeu4OEVyliCA81DoRGS1WtW3b1/17dvXk/UAQLFLOpyneU8ka99WhywWqdugKHUbGKmgIL4SBHB+OOQEoETb9mP+FAzpyUYR0RbdNi5O9dtwliCAC0PAAlAiOZ1G37ybrqVvpMk4pcoXBWvgk3EqXZFfiwAuHL9JAJQ4malOLZhi15a12ZKkVr3C1XtEDGcJAnAbAhaAEuXvnQ7NfTxZx/7KU3Co1Ht4jFpfHeHtsgAEGAIWgBJjw9eZWjjdLke2FF8uSAOnxKtqPaZgAOB+BCwAAS/XYfTpS6la+3GGJKluy1DdNi5OUXFMwQDAM84asCZNmlTkDVosFo0dO/a8CwIAd0o+mqf5Y5O1Z4tDktRtYKS6D4pSkJXxVgA856wBa8KECacss1jyfykZY05ZbowhYAHwGdt/ztZb4+1KS3IqPMqiW8fGquFlYd4uC0AJcNbj406ns8C//fv3q3Hjxrrlllv0ww8/yG63y263a/369br55pvVpEkT7d+/v1gKnzVrlqpXr66wsDC1atVKP/zww1nX//DDD1WvXj2FhYWpcePGWrp0abHUCaD4GWP0zYJ0vTIsSWlJTlWsHawRs0sTrgAUmyINQLjvvvtUp04dvfPOO7r00ksVHR2t6OhotWjRQu+++65q1aql++67z1O1uixcuFAjRozQ+PHj9fPPP6tJkybq3r27jhw5ctr1v/vuO91yyy268847tXHjRl133XW67rrrtGXLFo/XCqB4ZaU7Ne+JZH32cqqMU2rRM0wPvVpaCZUYcgqg+BQpYH3zzTe64oorznh/586dtXLlygsu6lyeffZZDR48WIMGDVKDBg306quvKiIiQnPmzDnt+s8//7x69OihRx99VPXr19fkyZPVvHlzvfTSSx6vFUDxST8WrheG2vXrf7NlDZb6PBKjW8bEKjSM8VYAileRAlZYWJgSExPPeP93332nsDDPHoLPycnRhg0b1KVLF9eyoKAgdenS5Yy1JSYmFlhfkrp3737WXgD4l03fZGvDOw11bL9TcWWD9MCsUmp7XYRr3CgAFKciHTO/9dZb9cILLyguLk4PPPCAatWqJUnauXOnXnjhBS1YsEAPPvigRwo96dixY8rLy1O5cuUKLC9Xrpz++OOP0z7m0KFDp13/0KFDZ3ye7OxsZWdnu26npKRIkhwOhxwOx/mWX8DJ7bhre76AnvxDIPWUl2v0xWsZWvtRliSrajWz6tZxMYqKs/h1f4G0j06iJ//giZ4C6fUprCIFrOnTp+vYsWN66aWXNGvWLAUF5R8AczqdMsbolltu0fTp0z1SaHGbOnWqJk6ceMryr7/+WhER7p31efny5W7dni+gJ//g7z1lp4Xo9yW1ZT8QI0mq2uqAKrf7S6u/83JhbuTv++h06Mk/uLOnjIwMt23LXxQpYIWGhurtt9/Wo48+qqVLl2rv3r2SpGrVqqlnz55q0qSJR4r8p4SEBFmtVh0+fLjA8sOHD6t8+fKnfUz58uWLtL4kjR49WiNGjHDdTklJUZUqVdStWzfFxMRcQAf/z+FwaPny5eratatCQgJjNml68g+B0NOuXxx6Z2Kq0pKMwiIt6v1omA6k/+XXPf1TIOyjf6Mn/+CJnk5+C1SSFDpgZWRk6LbbblPv3r1166236uKLL/ZkXWcUGhqqSy65RCtXrtR1110nKf8I2sqVK3X//fef9jFt2rTRypUrNWzYMNey5cuXq02bNmd8HpvNJpvNdsrykJAQt7+JPLFNb6Mn/+CPPRlj9N8PMvTZy6ly5kkVagVr0JNxiitvdGCpf/Z0NoHWj0RP/sKdPQXaa1MYhQ5YERERWrFihXr27OnJegplxIgRGjBggC699FK1bNlSM2fOVHp6ugYNGiRJ6t+/vypVqqSpU6dKkh566CF17NhRzzzzjHr16qX3339fP/30k15//XVvtgGgiLIynHp/aop++TZLknRJtzD1eTRGtvCgEjnGA4DvKtJXhO3atVNiYqIGDx7sqXoKpW/fvjp69KjGjRunQ4cOqWnTplq2bJlrIPu+fftc48MkqW3btlqwYIGeeOIJjRkzRnXq1NHixYvVqFEjb7UAoIgO78nV3CeSdHhPnqzB0nUPROuyGzhLEIBvKlLAeumll9S9e3c98cQTuueee1S5cmVP1XVO999//xm/Ely1atUpy/r06aM+ffp4uCoAnrDp2yy9/5Rd2ZlGsQlBGvhknKo3CvV2WQBwRkUKWE2aNFFubq6mTp2qqVOnKjg4+JRxShaLRXa73a1FAiiZ8nKNPn81Vavezz8DqXazUPWfGKvoUlYvVwYAZ1ekgNW7d28OxwMoFinH8/TW+GTt3JQ/tuqKfpG6ckiUrMH8DgLg+4oUsObNm+ehMgDg/+36NUfzxyYr5bhTtgiL+j0eq4s7cqFmAP6Dq58C8BnGGK35KEOfvpQ/BUO56sG646k4la3KryoA/uW8fmv99ddf2rhxo+x2u5xO5yn39+/f/4ILA1CyZGc49cF/UvTzivwpGJp1DlPfkTGyRRTpkqkA4BOKFLCysrI0YMAAffzxx3I6nbJYLDLGSFKBsVkELABFcWRfruY+nqxDu3MVZJWuvT9a7W9kCgYA/qtIfxqOGTNGixYt0pQpU7Rq1SoZYzR//nx9/fXXrkvl/PLLL56qFUAA+vW/WXr2ruM6tDtXMaWDdN8LpdShTyThCoBfK1LA+uijjzRo0CCNHDlSDRs2lCRVqlRJXbp00eeff664uDjNmjXLI4UCCCx5uUafvZyquY8nKzvDqFbTED08p7RqNmF+KwD+r0gB68iRI2rZsqUkKTw8XJKUnp7uur93795atGiRG8sDEIhSk/L06ogkfbMg//dHp74RGjqzlGJKM78VgMBQpIBVrlw5HT9+XFL+tQnj4+O1bds21/0pKSnKyspyb4UAAsqeLTl65o7j2vFzjkLDLRowKU7XPhDD/FYAAkqRBrm3atVKa9eu1ciRIyVJV199tZ5++mlVqFBBTqdTzz33nFq3bu2RQgH4N2OM1i3K0OIXU5WXK5WtZtUdU+JVrjpTMAAIPEX6zfbggw/qww8/VHZ2tmw2myZPnqzExETdfvvtkqRatWrphRde8EihAPxXdqZTH85I0Yav8o9wN+lk081jYhXGFAwAAlSRAla7du3Url071+0qVapo69at2rx5s6xWq+rVq6fgYP4aBfD/jv6VPwXDwZ35UzBcPTRaHfsyBQOAwHbBaSgoKEhNmjRxRy0AAsyWtVl690m7stKMoksFacCkONVqylmCAAJfkQJWxYoV1b59e9c/ghWA03HmGX35ZppWvJ1/lmCNxiEaMDlOsQmcJQigZChSwLr22mu1du1affTRR5KkmJgYtW3bVh06dFD79u3VokULhYSEeKRQAP4hPcWpdyYk648fciRJHfpE6Jr7ojlLEECJUqSA9corr0iSkpKStGbNGq1Zs0Zr167VuHHjlJubK5vNplatWunbb7/1SLEAfNuB7Q7NGZOsEwfzFGKT+o6M1SXdwr1dFgAUu/MagxUfH69rrrlG11xzjfbv368vv/xSzz77rP7880+tXr3a3TUC8AMbvs7Uwul2ObKlUhWsuuOpOFWqwxFtACVTkQPW1q1bXUev1qxZo/379ys2NlZt2rTRoEGD1L59e0/UCcBH5eUaLXk5Vas/yJAk1WsZqtsmxCkyhikYAJRcRQpYZcqU0YkTJ1S2bFm1b99eDz/8sGuwO6dcAyVPalKe5o9N1s5NDklSl9sj1fOuKAVZ+X0AoGQrUsA6fvy4goKCVK9ePdWvX1/169dXnTp1CFdACbT39xzNeyJZyUecsoVb1O+JWF3cMczbZQGATyhSwDp69KjWrl2rNWvWaNmyZZo6daokqWnTpq6pG9q1a6eEhASPFAvAN3z/eYY+eiZFeQ6pbFWr7niKS94AwD8V6Tdi6dKlde211+raa6+VJGVkZCgxMVFr1qzRBx98oJkzZ8pisSg3N9cjxQLwrtwco0XPpyjx00xJUqP2Nt36RKzCIhlvBQD/dN5/cm7fvl1r1qzR6tWrtWbNGu3evVtS/jgtAIEn+Wie5j2RrL2/OWSxSD3ujFKX/pEKCmKIAAD8W5EC1ksvvaTVq1dr7dq1Onz4sIwxqlGjhtq3b68xY8aoffv2uuiiizxVKwAv2flLjuaPTVbqCafCoyy6fXyc6rexebssAPBZRQpYw4YNU6NGjdS7d2/XmKsKFSp4qjYAXmaM0ZqPM/Tpi6ly5kkVagXrjqfilFCJ8VYAcDZFPoswNjbWU7UA8CE52UYfPm3XT8uyJEnNOoep76gY2cIZbwUA51KkgPXPcHXw4EEdOXJEtWvXVmRkpNsLA+A9Jw7lae6YJP31Z66CrNLVQ6PVsW8EU7IAQCEV+U/RTz/9VPXq1VPlypXVvHlzrV+/XpJ07NgxNWvWTIsXL3Z3jQCK0Y6NOXr2rmP6689cRcZZdM9z8ep0cyThCgCKoEgB67PPPtMNN9yghIQEjR8/XsYY130JCQmqVKmS5s6d6/YiAXieMUZrF2XolWEnlJ5sVOmiYD38ZoLqNGcwOwAUVZEC1qRJk9ShQwetXbtW99133yn3t2nTRhs3bnRbcQCKR67D6IP/pOjjZ1PkzMsfb/Xgy6UVX97q7dIAwC8VaQzWli1b9Oyzz57x/nLlyunIkSMXXBSA4pNyPE9zn0jWns3581v1uidKV/TjK0EAuBBFClgRERFKT08/4/27du1S6dKlL7goAMVj/7ZcvTU2VfajToVFWdSf+a0AwC2K9BXh5Zdfrvnz55/2UjiHDh3SG2+8oW7durmtOACec+i3BL3ygF32o06VrWbV8NdLE64AwE2KdARrypQpat26tVq0aKE+ffrIYrHoq6++0jfffKPXXntNxhiNHz/eU7UCcIO8XKPPX0nXH0trSZIatLXptnGxCo9ifisAcJciBay6detq7dq1euihhzR27FgZY/T0009Lkjp16qRZs2apevXqnqgTgBukpzj11vhk/fljjiTpitvC1WtIDNcTBAA3K/L1Lho2bKgVK1YoKSlJO3bskNPpVM2aNV0XeTbGMDgW8EEHdzk0Z3Syjh3IU0iYVKfbdvW4szXhCgA84Ly/E4iPj1eLFi3UqlUrlSlTRjk5OXr99ddVt25dd9YHwA02r87S83ef0LEDeSpVwar7XoxV2bonvF0WAASsQh3BysnJ0ZIlS7Rz507Fx8frqquuUsWKFSVJGRkZeumllzRz5kwdOnRItWrV8mjBAArP6TRaPj9dy2anSZJqNw/VgElxskXmadOfXi4OAALYOQPW33//rU6dOmnnzp2umdvDw8O1ZMkShYaGql+/fjpw4IBatmypF198UTfccIPHiwZwbjlZRgueTNYvq7IlSe1vjNC190fLGmyRw5Hn5eoAILCdM2A9/vjj2r17tx577DG1b99eu3fv1qRJkzRkyBAdO3ZMDRs21DvvvKOOHTsWR70ACiH5SJ5mj8q/WLM1WOrzSIxaXRXh7bIAoMQ4Z8Bavny5Bg0apKlTp7qWlS9fXn369FGvXr306aefKiiI07sBX7H39xzNGZ2slONORcZZNGhKvGo1CfV2WQBQopwzYB0+fFitW7cusOzk7TvuuINwBfiQn5dn6v2pdjlypAo1g3XntDiVrljkk4UBABfonL958/LyFBYWVmDZyduxsbGeqQpAkTidRstmp2n5/PxLWTW8zKbbxscqLII/gADAGwr1p+2ePXv0888/u27b7XZJ0vbt2xUXF3fK+s2bN3dPdQDOKTvTqQVT7Pr1f4PZr+gXqV53RynIyvxWAOAthQpYY8eO1dixY09Zfu+99xa4fXKS0bw8zlACikPS4TzNHp2kA3/myhoi3fRojFpeyWB2APC2cwasuXPnFkcdAIpo7285mj06WaknnIqKC9Kgp+JU82IGswOALzhnwBowYEBx1AGgCDZ8nan3p9mVmyNVrBWsO6fHq1R5q7fLAgD8D6cXAX7E6TT68o00rXg7fzB7o3Y23TYuVjYGswOATyFgAX4iO9OpdyfbtXl1/mD2zrdF6sohUVysGQB8EAEL8AP2Y3l6c2SS/tqWP5i978hYtegR7u2yAABnQMACfNzfOxx647EkJR/Jn5n9jqfiGcwOAD6OgAX4sK2J2Zo/PlnZGUZlq1o1+Ol4JVTibQsAvo7f1ICPWrsoQ4tmpsg4pdrNQzXoyThFxDCYHQD8AQEL8DHOPKNPZ6Vq9QcZkqSWV4arz6MxCg5hMDsA+Au/+3P4xIkTuvXWWxUTE6O4uDjdeeedSktLO+tjOnXqJIvFUuDfPffcU0wVA4WXneHU3MeTXeGq191Runk04QoA/I3fHcG69dZbdfDgQS1fvlwOh0ODBg3SkCFDtGDBgrM+bvDgwZo0aZLrdkQElxOBb0k+mn+m4IE/cxUcKvV7PFbNOnOmIAD4I78KWFu3btWyZcv0448/6tJLL5Ukvfjii7ryyis1Y8YMVaxY8YyPjYiIUPny5YurVKBIDmzPP1PQfjT/sjd3TotT9UacKQgA/sqvviJMTExUXFycK1xJUpcuXRQUFKT169ef9bHvvvuuEhIS1KhRI40ePVoZGRmeLhcolN++y9IL956Q/ahT5apb9dBrpQhXAODn/OoI1qFDh1S2bNkCy4KDg1WqVCkdOnTojI/r16+fqlWrpooVK+rXX3/VyJEjtW3bNi1atOiMj8nOzlZ2drbrdkpKiiTJ4XDI4XBcYCdybeuf/w0E9FQ03y3O0qcvpv/vTMEQ3T4xSuFRxuOvH/vJ9wVaPxI9+QtP9BRIr09hWYwxxttFjBo1StOnTz/rOlu3btWiRYs0f/58bdu2rcB9ZcuW1cSJEzV06NBCPd8333yjzp07a8eOHapVq9Zp15kwYYImTpx4yvIFCxYwfgsXzBhp1+oq2v9D/tfa5Rsf0UVd9yjI6vW3IwC4XUZGhvr16ye73a6YmBhvl1MsfCJgHT16VMePHz/rOjVr1tQ777yjhx9+WElJSa7lubm5CgsL04cffqjrr7++UM+Xnp6uqKgoLVu2TN27dz/tOqc7glWlShUdO3bMbT8cDodDy5cvV9euXRUSEuKWbXobPZ1bbo7RB9PTtOmbHElS9zvCdcVt4bJYiu9MQfaT7wu0fiR68hee6CklJUUJCQklKmD5xFeEZcqUUZkyZc65Xps2bZScnKwNGzbokksukZR/NMrpdKpVq1aFfr5NmzZJkipUqHDGdWw2m2w22ynLQ0JC3P4m8sQ2vY2eTi8z1ak5Y5K1Y2OOgqxS31GxatnTe2cKsp98X6D1I9GTv3BnT4H22hSGXw1yr1+/vnr06KHBgwfrhx9+0Lp163T//ffr5ptvdp1BeODAAdWrV08//PCDJGnnzp2aPHmyNmzYoD179mjJkiXq37+/OnTooIsvvtib7aCESTqUpxfuPaEdG3Nki7BoyIx4r4YrAIDn+MQRrKJ49913df/996tz584KCgpS79699cILL7judzgc2rZtm+sswdDQUK1YsUIzZ85Uenq6qlSpot69e+uJJ57wVgsogQ5sd+iNR5NkP+ZUbEKQBj8dr0p1St5fdABQUvhdwCpVqtRZJxWtXr26/jmsrEqVKvrvf/9bHKUBp7Xtx2zNfTz/gs3lawRryIx4xZezerssAIAH+V3AAvzJD19mauE0u5x5Uu1mobrjqTiFR/vVN/MAgPNAwAI8wBij5fPT9eWb+dfJbN4lTLeMiVVwKNcUBICSgIAFuFlertFHz6To+88yJUlX3BqpXndHKSiIcAUAJQUBC3CjnCyjt8Yn67d12bIESTcMi1G7G5iYFgBKGgIW4CYZKU69OTJJuzc7FBIq3T4xTo3bh3m7LACAFxCwADdIPpqn10Yk6dDuXIVHWXTn9HjVasIFmwGgpCJgARfo8N5cvTbihJIO589xNeSZeFWsxRxXAFCSEbCAC7D39xy98WiS0u1GZapYdc+z8SpVgbcVAJR0fBIA5+mP9dma+0SycjKNqtYP0eD/xCsqnjmuAAAELOC8bPg6Uwum5E8gWrdlqAY9GSdbBOEKAJCPgAUU0X8/SNfiF1Il/W8C0cdjFRzCHFcAgP9HwAIKyRijz19N1cp30iVJHfpE6NoHoplAFABwCgIWUAjGKX38TLp++CJbktTr7ih1vi1SFgvhCgBwKgIWcA65DqPfP6+to9vyZ2e/6bEYtb6K2dkBAGdGwALOIifLaP7YVB3dVlrWYOn2CXFq0onZ2QEAZ0fAAs4gMy3/0je7fnEoKDhPA6fEqdFlhCsAwLlxXjlwGmlJTr384Ant+sWhsEiLmvT5Q3VbcukbAEDhELCAf0k+mqcX7z+uv/7MVVRckO5+LkaxldO8XRYAwI8QsIB/OPpXrl6894SO7M1TXNkgPfByKVWqwzfpAICi4ZMD+J+/dzr06ogkpR53qkxlq+6ZWUqlylvlcDi8XRoAwM8QsADlX7T59YeTlJFqVLFWsO55Ll7RpazeLgsA4KcIWCjxdmzM0ZuPJSk706hawxANeTpeETF8ew4AOH8ELJRo237M1uxRSXJkS3UuCdWdU7loMwDgwhGwUGL99l2W5j2RrNwcqX4bmwY9GacQG5e+AQBcOAIWSqRf/5ult8YnKy9XatzBpv4T4xQcQrgCALgHAQslzsaVmXpnkl3OPKlZ5zDdOjZW1mDCFQDAfQhYKFF+XJap956yyzilS3uE6ZbRsQqyEq4AAO5FwEKJ8f1nGfrgPykyRmp9dbj6PBqjoCDCFQDA/QhYKBHWfpyuj59LlSS16x2h6x+KJlwBADyGgIWAt+r9dH36Un646nRzhK65L1oWC+EKAOA5BCwEtBVvp+mL1/Iv1Ny1f6R6Do4iXAEAPI6AhYC18p3/D1c974pSt4FRXq4IAFBSELAQkFa+m6bPX80PV1cOjlLXAYQrAEDx4ZogCDjfLEjX56/8/5ErwhUAoLgRsBBQvlmQrs9ezh/QzteCAABvIWAhYHz7j3DV407CFQDAewhYCAjfvpeuJf8LV93viFL3QYQrAID3ELDg91a9n64ls/4/XPW4g3AFAPAuAhb82qqF/z+JaPdBkYQrAIBPIGDBb/33g3R9+mJ+uOo2KFI97oz2ckUAAOQjYMEvrV2UocUv/C9cDeTIFQDAtxCw4Hd+WJqhj59NkSR1vi1SPe7k8jcAAN9CwIJf+XlFpt6flh+uOvSJUK+7CVcAAN9DwILf+PW/WXp3sl3GKbW5NlzXPRhNuAIA+CQCFvzC1u+z9db4ZDnzpEu7h+nGh2MIVwAAn0XAgs/bviFbc8ckKS9XanJ5mG4eHaugIMIVAMB3EbDg03b9mqM3RyXLkSM1vMym28bFyhpMuAIA+DYCFnzWvj8ceuPRJOVkGl3UIlQDJsUpOIRwBQDwfQQs+KS/dzj02vATyko3qtU0RHdOjVeIjXAFAPAPBCz4nKP7c/XK8CRlpBpVaxCiu/4Tr9AwwhUAwH8QsOBTko/m6ZXhJ5SW5FTF2sG6+5l4hUXwYwoA8C98csFnpCU79erwE0o65FRCZavueTZe4dH8iAIA/A+fXvAJWRlOvfFokg7vyVNsmSANfS5e0aWs3i4LAIDzQsCC1zmyjeaMTta+rQ5Fxlp0z7OlVKpCsLfLAgDgvBGw4FV5uUZvT0jW9g05soVbNGRGKZWvQbgCAPg3vwtYU6ZMUdu2bRUREaG4uLhCPcYYo3HjxqlChQoKDw9Xly5dtH37ds8WinNyOo0++E+KNq/JVnCodOf0OFWtH+LtsgAAuGB+F7BycnLUp08fDR06tNCP+c9//qMXXnhBr776qtavX6/IyEh1795dWVlZHqwUZ2OM0acvpeqHpZkKskr9J8apTnObt8sCAMAt/O67mIkTJ0qS5s2bV6j1jTGaOXOmnnjiCV177bWSpLfeekvlypXT4sWLdfPNN3uqVJzF8vnpWv1BhiSp76hYNW4f5uWKAABwH78LWEW1e/duHTp0SF26dHEti42NVatWrZSYmHjGgJWdna3s7GzX7ZSUFEmSw+GQw+FwS20nt+Ou7fmCwvT0/ZIsfflmuiTpmvsi1KxLsE+/BiV1P/mbQOsp0PqR6MlfeKKnQHp9CstijDHeLuJ8zJs3T8OGDVNycvJZ1/vuu+902WWX6e+//1aFChVcy2+66SZZLBYtXLjwtI+bMGGC62jZPy1YsEAREREXVHtJdnR7vH77tI5kLKrW5oBqtPvL2yUBADwsIyND/fr1k91uV0xMjLfLKRY+cQRr1KhRmj59+lnX2bp1q+rVq1dMFUmjR4/WiBEjXLdTUlJUpUoVdevWzW0/HA6HQ8uXL1fXrl0VEhIYg7vP1tOezQ69/nyKZKSWvWzq/XBjWSwXe6nSwitp+8lfBVpPgdaPRE/+whM9nfwWqCTxiYD18MMPa+DAgWddp2bNmue17fLly0uSDh8+XOAI1uHDh9W0adMzPs5ms8lmO3XQdUhIiNvfRJ7Yprf9u6dDu3M17/FU5eZIDdradNOjcbIG+9f1BUvCfgoEgdZToPUj0ZO/cGdPgfbaFIZPBKwyZcqoTJkyHtl2jRo1VL58ea1cudIVqFJSUrR+/foinYmI85d8NE+vPXwi/+LNDUM0YJL/hSsAAIrC76Zp2LdvnzZt2qR9+/YpLy9PmzZt0qZNm5SWluZap169evrkk08kSRaLRcOGDdOTTz6pJUuWaPPmzerfv78qVqyo6667zktdlByZqU69/nCSko84VbaqVXdNj1doGOEKABDYfOIIVlGMGzdO8+fPd91u1qyZJOnbb79Vp06dJEnbtm2T3W53rfPYY48pPT1dQ4YMUXJystq1a6dly5YpLIypATzJkW00e3SSDu7KVXTpIN39TLyi4vwu0wMAUGR+F7DmzZt3zjmw/n1ipMVi0aRJkzRp0iQPVoZ/cuYZvfdksnZucigs0qK7Z8RzfUEAQInB4QS4nTHSklkZ+mVVtqwh0h1T41SpTskb4AgAKLk4pAC32/9DBe1anX8ZolufiOUSOACAEocjWHCrTd9ka9fqqpKk6x6MVrPO4V6uCACA4kfAgtvs+iVHH0zLP5uz3Y1h6nhTpJcrAgDAOwhYcIuj+3M1e3SSch1SQu0TuuoeLicEACi5CFi4YGnJTr3+aJIyUoyq1LOq/lU7FWRlrisAQMlFwMIFOTnX1bG/8lSqglUDp8TIGuL0dlkAAHgVZxHivDmdRgum2LVns0PhURYNeTpe0aXMuR8IAECA4wgWztvS19O06ZssWYOlQU/FqVx18joAABIBC+fpu08ztPKddElS35HMdQUAwD8RsFBkf6zP1sfPpkiSut8RpRY9mesKAIB/ImChSA7ucmje2GQ586RLe4Sp+yDmugIA4N8IWCi0tGSn3hyZrOwMo1pNQ9R3ZKwsFqZjAADg3whYKJRch9G8J5J04uD/pmN4Ml7BIYQrAABOh4CFczLG6KMZKdq5yaGwSIsG/ydeUXH86AAAcCZ8SuKc/rswQ+u/yJQlSOo/IU7lazAdAwAAZ0PAwln9ti5LS2alSpKuvT9a9dswHQMAAOdCwMIZHdzl0NsT7DJGan11uDr04QLOAAAUBgELp5WW9L8zBjONajcLVe8RMZwxCABAIRGwcIrcHKM5j+efMZhQyaqBT8ZxxiAAAEVAwEIBxhh9OCNFu3/NP2PwrunxiozlxwQAgKLgkxMFrPk4Qz8szT9jcMAkLuAMAMD5IGDBZcfP2fr0xfwzBq+5N1r1WnHGIAAA54OABUnSiUN5mjcu/xqDl3QLU8e+nDEIAMD5ImBBOVlGc8YkKT3ZqPJFwbqJawwCAHBBCFglnDFGC6fbdeDPXEXFBemOp+IVaiNcAQBwIQhYJdyq9zP08/IsBVmlAZPjFF/e6u2SAADwewSsEmzbj9n67JX8Qe3XPRit2s1CvVwRAACBgYBVQh07kKu3xiXLOKVWvcLV7gYGtQMA4C4ErBIoO8OpOaOTlZFqVK1BCJfBAQDAzQhYJYwxRu89ZdfBXbmKLh2kgVPiFMKgdgAA3IqAVcL8d2GGflmVLWuwNOjJOMWVYVA7AADuRsAqQXZuyvn/Qe0PRKtGYwa1AwDgCQSsEsJ+LE/zx///TO2XMagdAACPIWCVAHm5RvPHJSv1uFMVagarz6MMagcAwJMIWCXA56+kavevDoVFWjRoSpxs4ex2AAA8iU/aALfpmyytWpghSbplTKzKVAn2ckUAAAQ+AlYAO7wnV+9PtUuSrugXqYs7hnm5IgAASgYCVoDKznBq7hNJys40qt08VFcOifJ2SQAAlBgErABkjNHC6Sk6vCdPsQlB6j8hVtZgBrUDAFBcCFgBaM3HGdq4MktBVmnA5DhFl2IyUQAAihMBK8Ds+8OhJS/lTyZ6zX1MJgoAgDcQsAJIZqpT88cmKy9XurijTR36MJkoAADeQMAKEMYYvT/drhMH81SqglU3j4plMlEAALyEgBUg1i7K0K//u4jzgElxCo9m1wIA4C18CgeA/X849On/xl1dfW+0qtYP8XJFAACUbAQsP5eZ5tT8ccnKc0iN2zPuCgAAX0DA8mPGGC2cZtfxv/837mo0464AAPAFBCw/tm5Rhn7537ir/hNjFRHD7gQAwBfwieyn9m9zaPE/xl1Va8B8VwAA+AoClh/KSnfqrf+Nu2rEuCsAAHwOAcsPffRsio4dyFN8uSDGXQEA4IMIWH7mp68yteGrLFmCpNvGxymScVcAAPgcPp39yLEDufromRRJUreBUap5MeOuAADwRX4XsKZMmaK2bdsqIiJCcXFxhXrMwIEDZbFYCvzr0aOHZwt1s7xco3cm2pWdYVTj4hB17R/p7ZIAAMAZBHu7gKLKyclRnz591KZNG82ePbvQj+vRo4fmzp3rum2z2TxRnscsm52mvb87FBZl0e3j4mQNZtwVAAC+yu8C1sSJEyVJ8+bNK9LjbDabypcv74GKPG/Hz9la+U66JKnvY7GKL2/1ckUAAOBs/O4rwvO1atUqlS1bVnXr1tXQoUN1/Phxb5dUKOl2p96ZbJcxUqurwtX0ijBvlwQAAM7B745gnY8ePXrohhtuUI0aNbRz506NGTNGPXv2VGJioqzW0x8Nys7OVnZ2tut2Skr+4HKHwyGHw+GWuk5u50zbM8bo/Wlpsh91KqFKkK6+N9xtz+0p5+rJH9GTfwi0ngKtH4me/IUnegqk16ewLMYY4+0iRo0apenTp591na1bt6pevXqu2/PmzdOwYcOUnJxc5OfbtWuXatWqpRUrVqhz586nXWfChAmuryP/acGCBYqIKJ6JPf/eVFZ/Lq8hS5BTzW/7TdHlMorleQEAcKeMjAz169dPdrtdMTEx3i6nWPhEwDp69Og5v7KrWbOmQkP/f1qCCwlYklSmTBk9+eSTuvvuu097/+mOYFWpUkXHjh1z2w+Hw+HQ8uXL1bVrV4WEhBS47/CeXL1wj12ObOmqoRHqcFO4W57T087Wk7+iJ/8QaD0FWj8SPfkLT/SUkpKihISEEhWwfOIrwjJlyqhMmTLF9nx//fWXjh8/rgoVKpxxHZvNdtozDUNCQtz+Jvr3NnMdRu8/lR+u6rYM1eW3RCsoyL/OGvTE6+Rt9OQfAq2nQOtHoid/4c6eAu21KQy/G+S+b98+bdq0Sfv27VNeXp42bdqkTZs2KS0tzbVOvXr19Mknn0iS0tLS9Oijj+r777/Xnj17tHLlSl177bWqXbu2unfv7q02zmrZ7DQd2J6ryDiL+j0e63fhCgCAks4njmAVxbhx4zR//nzX7WbNmkmSvv32W3Xq1EmStG3bNtntdkmS1WrVr7/+qvnz5ys5OVkVK1ZUt27dNHnyZJ+cC2vXLzn65t38KRluejRWMaWZkgEAAH/jdwFr3rx555wD65/DysLDw/XVV195uCr3yEp36t0n86dkaHlluC7uyJQMAAD4I7/7ijCQLX4hVScO5qlUBauufyja2+UAAIDzRMDyEZtXZ2n9F5myWKR+T8QqLJJdAwCAv+JT3AeknnBq4X/yx4xd3i9StZqEnuMRAADAlxGwvMwY6aMZaUpPNqpYO1g974zydkkAAOAC+d0g90Bz8Ncy+jPRIWuIdNu4WAWHMiUDAAD+jiNYXnTsQJ52fFtNknTV3dGqULPkTcQGAEAgImB5SV6u0cKpaXI6rKrVLFgdbiqe6xsCAADPI2B5SbrdKUeOkTU0VzeNjGK2dgAAAggBy0tiSlt1/6xYNb15q+LLMVs7AACBhIDlRcEhFkWXy/B2GQAAwM0IWAAAAG5GwAIAAHAzAhYAAICbEbAAAADcjIAFAADgZgQsAAAANyNgAQAAuBkBCwAAwM0IWAAAAG5GwAIAAHAzAhYAAICbEbAAAADcjIAFAADgZgQsAAAANyNgAQAAuBkBCwAAwM0IWAAAAG4W7O0C/IUxRpKUkpLitm06HA5lZGQoJSVFISEhbtuuN9GTf6An3xdo/Uj05C880dPJz86Tn6UlAQGrkFJTUyVJVapU8XIlAAD4p9TUVMXGxnq7jGJhMSUpTl4Ap9Opv//+W9HR0bJYLG7ZZkpKiqpUqaL9+/crJibGLdv0NnryD/Tk+wKtH4me/IUnejLGKDU1VRUrVlRQUMkYncQRrEIKCgpS5cqVPbLtmJiYgHljnkRP/oGefF+g9SPRk79wd08l5cjVSSUjRgIAABQjAhYAAICbEbC8yGazafz48bLZbN4uxW3oyT/Qk+8LtH4kevIXgdiTNzDIHQAAwM04ggUAAOBmBCwAAAA3I2ABAAC4GQELAADAzQhYHjRlyhS1bdtWERERiouLK9RjjDEaN26cKlSooPDwcHXp0kXbt28vsM6JEyd06623KiYmRnFxcbrzzjuVlpbmgQ5OVdTn3rNnjywWy2n/ffjhh671Tnf/+++/Xxwtndfr2alTp1Pqveeeewqss2/fPvXq1UsREREqW7asHn30UeXm5nqyFZei9nTixAk98MADqlu3rsLDw1W1alU9+OCDstvtBdYrzv00a9YsVa9eXWFhYWrVqpV++OGHs67/4Ycfql69egoLC1Pjxo21dOnSAvcX5r3laUXp6Y033lD79u0VHx+v+Ph4denS5ZT1Bw4ceMr+6NGjh6fbKKAoPc2bN++UesPCwgqs42/76XS/CywWi3r16uVax5v7afXq1br66qtVsWJFWSwWLV68+JyPWbVqlZo3by6bzabatWtr3rx5p6xT1PdniWTgMePGjTPPPvusGTFihImNjS3UY6ZNm2ZiY2PN4sWLzS+//GKuueYaU6NGDZOZmelap0ePHqZJkybm+++/N2vWrDG1a9c2t9xyi4e6KKioz52bm2sOHjxY4N/EiRNNVFSUSU1Nda0nycydO7fAev/s2ZPO5/Xs2LGjGTx4cIF67Xa76/7c3FzTqFEj06VLF7Nx40azdOlSk5CQYEaPHu3pdowxRe9p8+bN5oYbbjBLliwxO3bsMCtXrjR16tQxvXv3LrBece2n999/34SGhpo5c+aY3377zQwePNjExcWZw4cPn3b9devWGavVav7zn/+Y33//3TzxxBMmJCTEbN682bVOYd5bnlTUnvr162dmzZplNm7caLZu3WoGDhxoYmNjzV9//eVaZ8CAAaZHjx4F9seJEyeKpR9jit7T3LlzTUxMTIF6Dx06VGAdf9tPx48fL9DPli1bjNVqNXPnznWt4839tHTpUvP444+bRYsWGUnmk08+Oev6u3btMhEREWbEiBHm999/Ny+++KKxWq1m2bJlrnWK+hqVVASsYjB37txCBSyn02nKly9vnn76adey5ORkY7PZzHvvvWeMMeb33383ksyPP/7oWufLL780FovFHDhwwO21/5O7nrtp06bmjjvuKLCsMG98Tzjfnjp27GgeeuihM96/dOlSExQUVODD45VXXjExMTEmOzvbLbWfibv20wcffGBCQ0ONw+FwLSuu/dSyZUtz3333uW7n5eWZihUrmqlTp552/Ztuusn06tWrwLJWrVqZu+++2xhTuPeWpxW1p3/Lzc010dHRZv78+a5lAwYMMNdee627Sy20ovZ0rt+FgbCfnnvuORMdHW3S0tJcy7y9n04qzPv3scceMw0bNiywrG/fvqZ79+6u2xf6GpUUfEXoQ3bv3q1Dhw6pS5curmWxsbFq1aqVEhMTJUmJiYmKi4vTpZde6lqnS5cuCgoK0vr16z1anzuee8OGDdq0aZPuvPPOU+677777lJCQoJYtW2rOnDkyxTBF24X09O677yohIUGNGjXS6NGjlZGRUWC7jRs3Vrly5VzLunfvrpSUFP3222/ub+Qf3PUzYrfbFRMTo+Dggpcs9fR+ysnJ0YYNGwq8D4KCgtSlSxfX++DfEhMTC6wv5b/eJ9cvzHvLk86np3/LyMiQw+FQqVKlCixftWqVypYtq7p162ro0KE6fvy4W2s/k/PtKS0tTdWqVVOVKlV07bXXFng/BMJ+mj17tm6++WZFRkYWWO6t/VRU53ovueM1Kim42LMPOXTokCQV+FA+efvkfYcOHVLZsmUL3B8cHKxSpUq51vFkfRf63LNnz1b9+vXVtm3bAssnTZqkK664QhEREfr666917733Ki0tTQ8++KDb6j+d8+2pX79+qlatmipWrKhff/1VI0eO1LZt27Ro0SLXdk+3H0/e50nu2E/Hjh3T5MmTNWTIkALLi2M/HTt2THl5ead9/f7444/TPuZMr/c/3zcnl51pHU86n57+beTIkapYsWKBD7YePXrohhtuUI0aNbRz506NGTNGPXv2VGJioqxWq1t7+Lfz6alu3bqaM2eOLr74Ytntds2YMUNt27bVb7/9psqVK/v9fvrhhx+0ZcsWzZ49u8Byb+6nojrTeyklJUWZmZlKSkq64J/lkoKAVUSjRo3S9OnTz7rO1q1bVa9evWKq6MIVtqcLlZmZqQULFmjs2LGn3PfPZc2aNVN6erqefvrp8/7g9nRP/wwejRs3VoUKFdS5c2ft3LlTtWrVOu/tnk1x7aeUlBT16tVLDRo00IQJEwrc5+79hMKZNm2a3n//fa1atarAoPCbb77Z9f+NGzfWxRdfrFq1amnVqlXq3LmzN0o9qzZt2qhNmzau223btlX9+vX12muvafLkyV6szD1mz56txo0bq2XLlgWW+9t+gnsQsIro4Ycf1sCBA8+6Ts2aNc9r2+XLl5ckHT58WBUqVHAtP3z4sJo2bepa58iRIwUel5ubqxMnTrgeX1SF7elCn/ujjz5SRkaG+vfvf851W7VqpcmTJys7O/u8rodVXD39s15J2rFjh2rVqqXy5cufclbN4cOHJcmn91Nqaqp69Oih6OhoffLJJwoJCTnr+he6n04nISFBVqvV9XqddPjw4TPWX758+bOuX5j3liedT08nzZgxQ9OmTdOKFSt08cUXn3XdmjVrKiEhQTt27PD4B/eF9HRSSEiImjVrph07dkjy7/2Unp6u999/X5MmTTrn8xTnfiqqM72XYmJiFB4eLqvVesH7vcTw9iCwkqCog9xnzJjhWma32087yP2nn35yrfPVV18V6yD3833ujh07nnJW2pk8+eSTJj4+/rxrLSx3vZ5r1641kswvv/xijPn/Qe7/PKvmtddeMzExMSYrK8t9DZzG+fZkt9tN69atTceOHU16enqhnstT+6lly5bm/vvvd93Oy8szlSpVOusg96uuuqrAsjZt2pwyyP1s7y1PK2pPxhgzffp0ExMTYxITEwv1HPv37zcWi8V8+umnF1xvYZxPT/+Um5tr6tata4YPH26M8d/9ZEz+73mbzWaOHTt2zuco7v10kgo5yL1Ro0YFlt1yyy2nDHK/kP1eUhCwPGjv3r1m48aNrmkJNm7caDZu3FhgeoK6deuaRYsWuW5PmzbNxMXFmU8//dT8+uuv5tprrz3tNA3NmjUz69evN2vXrjV16tQp1mkazvbcf/31l6lbt65Zv359gcdt377dWCwW8+WXX56yzSVLlpg33njDbN682Wzfvt28/PLLJiIiwowbN87j/RhT9J527NhhJk2aZH766Seze/du8+mnn5qaNWuaDh06uB5zcpqGbt26mU2bNplly5aZMmXKFOs0DUXpyW63m1atWpnGjRubHTt2FDidPDc31xhTvPvp/fffNzabzcybN8/8/vvvZsiQISYuLs51Vubtt99uRo0a5Vp/3bp1Jjg42MyYMcNs3brVjB8//rTTNJzrveVJRe1p2rRpJjQ01Hz00UcF9sfJ3x+pqanmkUceMYmJiWb37t1mxYoVpnnz5qZOnToeD/Hn29PEiRPNV199ZXbu3Gk2bNhgbr75ZhMWFmZ+++23An370346qV27dqZv376nLPf2fkpNTXV99kgyzz77rNm4caPZu3evMcaYUaNGmdtvv921/slpGh599FGzdetWM2vWrNNO03C21wj5CFgeNGDAACPplH/ffvutax39b16hk5xOpxk7dqwpV66csdlspnPnzmbbtm0Ftnv8+HFzyy23mKioKBMTE2MGDRpUILR50rmee/fu3af0aIwxo0ePNlWqVDF5eXmnbPPLL780TZs2NVFRUSYyMtI0adLEvPrqq6dd1xOK2tO+fftMhw4dTKlSpYzNZjO1a9c2jz76aIF5sIwxZs+ePaZnz54mPDzcJCQkmIcffrjAlAe+1NO333572p9VSWb37t3GmOLfTy+++KKpWrWqCQ0NNS1btjTff/+9676OHTuaAQMGFFj/gw8+MBdddJEJDQ01DRs2NF988UWB+wvz3vK0ovRUrVq10+6P8ePHG2OMycjIMN26dTNlypQxISEhplq1ambw4MHF/iFXlJ6GDRvmWrdcuXLmyiuvND///HOB7fnbfjLGmD/++MNIMl9//fUp2/L2fjrTe/tkDwMGDDAdO3Y85TFNmzY1oaGhpmbNmgU+o04622uEfBZjiuFceAAAgBKEebAAAADcjIAFAADgZgQsAAAANyNgAQAAuBkBCwAAwM0IWAAAAG5GwAIAAHAzAhYAAICbEbAA+I0PPvhAFotFn3zyySn3NWnSRBaLRd9+++0p91WtWlVt27YtjhIBQBIBC4AfadeunSRp7dq1BZanpKRoy5YtCg4O1rp16wrct3//fu3fv9/1WAAoDgQsAH6jYsWKqlGjxikBKzExUcYY9enT55T7Tt4mYAEoTgQsAH6lXbt22rhxozIzM13L1q1bp4YNG6pnz576/vvv5XQ6C9xnsVh02WWXeaNcACUUAQuAX2nXrp0cDofWr1/vWrZu3Tq1bdtWbdu2ld1u15YtWwrcV69ePZUuXdob5QIooQhYAPzKv8dh5ebmav369brssstUq1YtlStXznVfamqqNm/ezNeDAIodAQuAX6lfv75Kly7tClG//PKL0tPTXWcJtm3b1jXQPTExUXl5eQQsAMWOgAXAr1gsFrVt29Y11mrdunUqW7asateuLalgwDr5XwIWgOJGwALgd9q1aye73a7Nmze7xl+d1LZtW+3du1cHDhzQ2rVrVbFiRdWsWdOL1QIoiQhYAPzOP8dhrVu3rsAZgpdccolsNptWrVrlGpsFAMWNgAXA71x66aUKCwvTu+++qwMHDhQ4gmWz2dS8eXPNmjVL6enpfD0IwCsIWAD8TmhoqFq0aKHExETZbDZdcsklBe5v27atEhMTJTH+CoB3ELAA+KWTwenkV4L/dPJrwejoaDVp0qTYawMAizHGeLsIAACAQMIRLAAAADcjYAEAALgZAQsAAMDNCFgAAABuRsACAABwMwIWAACAmxGwAAAA3IyABQAA4GYELAAAADcjYAEAALgZAQsAAMDNCFgAAABuRsACAABwMwIWAACAmxGwAAAA3IyABQAA4GYELAAAADcjYAEAALgZAQsAAMDNCFgAAABuRsACAABwMwIWAACAm/0fkIaNQe1SpwsAAAAASUVORK5CYII=' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -226,21 +283,13 @@
     }
    ],
    "source": [
-    "sigmoid_reward_widget(lambda e, a: 2.0 / (1.0 + np.exp(- e * a)) - (a > 0))"
+    "sinh_reward_widget(lambda w, alpha: np.sinh(w * alpha), 2.5)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "0c07b29c-9c1d-4605-b966-b95f7ee3f521",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b91dd971-aa16-43ca-95e5-b20341f89df1",
+   "id": "83006805-e9e0-4de3-a279-d3feb21f12d0",
    "metadata": {},
    "outputs": [],
    "source": []
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index c00cb199..5ea80384 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -75,9 +75,9 @@ def serialise(self) -> dict[str, float | NDArray]:
 
 class SinhReward(RewardFn):
     weight: jax.Array
-    scale: float
     extractor: Callable[..., jax.Array]
     serializer: Callable[[jax.Array], dict[str, jax.Array]]
+    scale: float
 
     def __init__(
         self,
@@ -87,17 +87,18 @@ def __init__(
         n_weights: int,
         extractor: Callable[..., jax.Array],
         serializer: Callable[[jax.Array], dict[str, jax.Array]],
-        scale: float = 2.0,
+        scale: float = 2.5,
         std: float = 1.0,
         mean: float = 0.0,
     ) -> None:
         self.weight = jax.random.normal(key, (n_agents, n_weights)) * std + mean
         self.extractor = extractor
         self.serializer = serializer
+        self.scale = scale
 
     def __call__(self, *args) -> jax.Array:
         extracted = self.extractor(*args)
-        return jax.vmap(jnp.dot)(extracted, self.weight)
+        return jax.vmap(jnp.dot)(extracted, jnp.sinh(self.weight * self.scale))
 
     def serialise(self) -> dict[str, float | NDArray]:
         return jax.tree_map(_item_or_np, self.serializer(self.weight))

From 18c93813bb6a06344a6f5e9fe402d72273e26460 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 7 Feb 2024 18:00:35 +0900
Subject: [PATCH 245/337] Fix scheduled num/loc fns

---
 src/emevo/environments/env_utils.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index 142b79c6..a5fa3dd7 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -111,7 +111,7 @@ def initial(self) -> int:
 
     def __call__(self, n_steps: int, state: FoodNumState) -> FoodNumState:
         index = jnp.digitize(n_steps, bins=self._intervals)
-        return jax.lax.switch(index, self._numfn_list, state)
+        return jax.lax.switch(index, self._numfn_list, n_steps, state)
 
 
 class ReprNum(str, enum.Enum):
@@ -364,7 +364,7 @@ def __call__(
         state: LocatingState,
     ) -> jax.Array:
         index = jnp.digitize(n_steps, bins=self._intervals)
-        return jax.lax.switch(index, self._locfn_list, key, state)
+        return jax.lax.switch(index, self._locfn_list, key, n_steps, state)
 
 
 def nth_true(boolean_array: jax.Array, n: int) -> jax.Array:

From 89db20f2ccbff55f91854dbdab1986c584a106e7 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 10 Feb 2024 01:20:25 +0900
Subject: [PATCH 246/337] smallbody

---
 config/env/20240206-multi.toml            |  1 +
 config/env/20240210-square-smallbody.toml | 30 +++++++++++++++++++++++
 2 files changed, 31 insertions(+)
 create mode 100644 config/env/20240210-square-smallbody.toml

diff --git a/config/env/20240206-multi.toml b/config/env/20240206-multi.toml
index 0c8d96c9..68784824 100644
--- a/config/env/20240206-multi.toml
+++ b/config/env/20240206-multi.toml
@@ -10,6 +10,7 @@ food_loc_fn = [
    ["gaussian", [360.0, 270.0], [48.0, 36.0]],
    ["gaussian", [120.0, 90.0], [48.0, 36.0]],
 ]
+# food_color = [[254, 2, 162, 255], [2, 254, 162, 255]]
 agent_loc_fn = "uniform"
 xlim = [0.0, 480.0]
 ylim = [0.0, 360.0]
diff --git a/config/env/20240210-square-smallbody.toml b/config/env/20240210-square-smallbody.toml
new file mode 100644
index 00000000..24170a69
--- /dev/null
+++ b/config/env/20240210-square-smallbody.toml
@@ -0,0 +1,30 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 50
+basic_energy_consumption = 1e-4
+food_num_fn = ["logistic", 20, 0.01, 50]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 7.5
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 089ebf6b9d99961aa37e97420d0a9801ae9c7ec3 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 10 Feb 2024 15:11:22 +0900
Subject: [PATCH 247/337] Food label in obs

---
 experiments/cf_asexual_evo.py             |   1 +
 src/emevo/environments/circle_foraging.py | 113 ++++++++++++++++---
 src/emevo/environments/moderngl_vis.py    |  25 ++++-
 src/emevo/exp_utils.py                    |  16 ++-
 tests/test_observe.py                     | 129 ++++++++++++++++++----
 5 files changed, 241 insertions(+), 43 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 3f8237b2..993a0320 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -188,6 +188,7 @@ def step_rollout(
             static_circle_axy=phys.static_circle.p.into_axy(),
             circle_is_active=phys.circle.is_active,
             static_circle_is_active=phys.static_circle.is_active,
+            static_circle_label=phys.static_circle.label,
         )
         return (state_t1db, obs_t1), (rollout, log, phys_state)
 
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 1a0dc747..0790e947 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -239,7 +239,44 @@ def cr(shape: Circle, state: State) -> Raycast:
     return jnp.where(obs == jnp.max(obs, axis=-1, keepdims=True), obs, -1.0)
 
 
-_vmap_obs = jax.vmap(_observe_closest, in_axes=(None, 0, 0, None))
+def _observe_closest_with_food_labels(
+    n_food_labels: int,
+    shaped: ShapeDict,
+    p1: jax.Array,
+    p2: jax.Array,
+    stated: StateDict,
+) -> jax.Array:
+    def cr(shape: Circle, state: State) -> Raycast:
+        return circle_raycast(0.0, 1.0, p1, p2, shape, state)
+
+    rc = cr(shaped.circle, stated.circle)
+    to_c = jnp.where(rc.hit, 1.0 - rc.fraction, -1.0)
+    rc = cr(shaped.static_circle, stated.static_circle)
+    to_sc = jnp.where(rc.hit, 1.0 - rc.fraction, -1.0)
+    foodlabel_onehot = jax.nn.one_hot(
+        stated.static_circle.label,
+        n_food_labels,
+        dtype=bool,
+    )
+    to_sc_all = jnp.where(foodlabel_onehot, jnp.expand_dims(to_sc, axis=1), -1.0)
+    rc = segment_raycast(1.0, p1, p2, shaped.segment, stated.segment)
+    to_seg = jnp.where(rc.hit, 1.0 - rc.fraction, -1.0)
+    obs = jnp.concatenate(
+        (
+            jnp.max(to_c, keepdims=True),
+            # (N_FOOD, N_LABEL) -> (N_LABEL,)
+            jnp.max(to_sc_all, axis=0),
+            jnp.max(to_seg, keepdims=True),
+        )
+    )
+    return jnp.where(obs == jnp.max(obs, axis=-1, keepdims=True), obs, -1.0)
+
+
+_vmap_obs_closest = jax.vmap(_observe_closest, in_axes=(None, 0, 0, None))
+_vmap_obs_closest_with_food = jax.vmap(
+    _observe_closest_with_food_labels,
+    in_axes=(None, None, 0, 0, None),
+)
 
 
 def _get_sensors(
@@ -269,11 +306,15 @@ def get_sensor_obs(
     n_sensors: int,
     sensor_range: tuple[float, float],
     sensor_length: float,
+    n_food_labels: int | None,
     stated: StateDict,
 ) -> jax.Array:
     assert stated.circle is not None
     p1, p2 = _get_sensors(shaped, n_sensors, sensor_range, sensor_length, stated)
-    return _vmap_obs(shaped, p1, p2, stated)
+    if n_food_labels is None:
+        return _vmap_obs_closest(shaped, p1, p2, stated)
+    else:
+        return _vmap_obs_closest_with_food(n_food_labels, shaped, p1, p2, stated)
 
 
 @functools.partial(jax.jit, static_argnums=(0, 1))
@@ -318,6 +359,8 @@ def __init__(
         food_num_fn: _MaybeNumFn | list[_MaybeNumFn] = "constant",
         food_loc_fn: _MaybeLocatingFn | list[_MaybeLocatingFn] = "gaussian",
         agent_loc_fn: LocatingFn | str | tuple[str, ...] = "uniform",
+        food_energy_coef: Iterable[float] = (1.0,),
+        food_color: Iterable[tuple] = (FOOD_COLOR,),
         xlim: tuple[float, float] = (0.0, 200.0),
         ylim: tuple[float, float] = (0.0, 200.0),
         env_radius: float = 120.0,
@@ -338,6 +381,7 @@ def __init__(
         min_force: float = -20.0,
         init_energy: float = 20.0,
         energy_capacity: float = 100.0,
+        observe_food_label: bool = False,
         force_energy_consumption: float = 0.01 / 40.0,
         basic_energy_consumption: float = 0.0,
         energy_share_ratio: float = 0.4,
@@ -362,6 +406,10 @@ def __init__(
         self._food_radius = food_radius
         self._foodloc_interval = foodloc_interval
         self._n_food_sources = n_food_sources
+        self._food_energy_coef = jnp.expand_dims(
+            jnp.array(list(food_energy_coef)),
+            axis=0,
+        )
         self._food_loc_fns, self._initial_foodloc_states = [], []
         self._food_num_fns, self._initial_foodnum_states = [], []
         if n_food_sources > 1:
@@ -523,17 +571,50 @@ def place_newborn_neighbor(
             sensor_range_tuple = SensorRange(sensor_range).as_tuple()
         else:
             sensor_range_tuple = sensor_range
-        self._sensor_obs = jax.jit(
-            functools.partial(
-                get_sensor_obs,
-                shaped=self._physics.shaped,
-                n_sensors=n_agent_sensors,
-                sensor_range=sensor_range_tuple,
-                sensor_length=sensor_length,
+
+        if observe_food_label:
+            assert (
+                self._n_food_sources > 1
+            ), "n_food_sources should be larager than 1 to include food label obs"
+
+            self._sensor_obs = jax.jit(
+                functools.partial(
+                    get_sensor_obs,
+                    shaped=self._physics.shaped,
+                    n_sensors=n_agent_sensors,
+                    sensor_range=sensor_range_tuple,
+                    sensor_length=sensor_length,
+                    n_food_labels=self._n_food_sources,
+                )
             )
-        )
+
+            def food_collision_with_labels(
+                c2sc: jax.Array,
+                label: jax.Array,
+            ) -> jax.Array:
+                onehot = jax.nn.one_hot(label, self._n_food_sources)  # (FOOD, LABEL)
+                expanded_c2sc = jnp.expand_dims(c2sc, axis=2)  # (AGENT, FOOD, 1)
+                expanded_onehot = jnp.expand_dims(onehot, axis=2)  # (1, FOOD, LABEL)
+                return jnp.max(expanded_c2sc * expanded_onehot, axis=1)
+
+            self._food_collision = food_collision_with_labels
+
+        else:
+            self._sensor_obs = jax.jit(
+                functools.partial(
+                    get_sensor_obs,
+                    shaped=self._physics.shaped,
+                    n_sensors=n_agent_sensors,
+                    sensor_range=sensor_range_tuple,
+                    sensor_length=sensor_length,
+                    n_food_labels=None,
+                )
+            )
+
+            self._food_collision = lambda c2sc, _: jnp.max(c2sc, axis=1, keepdims=True)
 
         # For visualization
+        self._food_color = np.array(list(food_color))
         self._get_sensors = jax.jit(
             functools.partial(
                 _get_sensors,
@@ -634,10 +715,13 @@ def step(
         c2c = self._physics.get_contact_mat("circle", "circle", contacts)
         c2sc = self._physics.get_contact_mat("circle", "static_circle", contacts)
         seg2c = self._physics.get_contact_mat("segment", "circle", contacts)
-        # This is also used in computing energy_delta
-        food_collision = jnp.max(c2sc, axis=1)
+        food_collision = self._food_collision(c2sc, stated.static_circle.label)
         collision = jnp.stack(
-            (jnp.max(c2c, axis=1), food_collision, jnp.max(seg2c, axis=0)),
+            (
+                jnp.max(c2c, axis=1, keepdims=True),  # (N, 1)
+                food_collision,  # (N, N_LABELS)
+                jnp.max(seg2c, axis=0, keepdims=True).T,
+            ),
             axis=1,
         )
         # Gather sensor obs
@@ -645,7 +729,7 @@ def step(
         # energy_delta = food - coef * |force|
         force_norm = jnp.sqrt(f1_raw**2 + f2_raw**2).ravel()
         energy_delta = (
-            food_collision
+            jnp.sum(food_collision * self._food_energy_coef, axis=1)
             - self._force_energy_consumption * force_norm
             - self._basic_energy_consumption
         )
@@ -949,6 +1033,7 @@ def visualizer(
             y_range=self._y_range,
             space=self._physics,
             stated=state.physics,
+            food_color=self._food_color,
             figsize=figsize,
             backend=backend,
             sensor_fn=self._get_sensors,
diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index a690516a..6a5346e1 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -296,6 +296,12 @@ def _get_clip_ranges(lengthes: list[float]) -> list[tuple[float, float]]:
     return res
 
 
+def _get_sc_color(colors: NDArray, state: State) -> NDArray:
+    label = np.array(state.label)
+    c = colors[label].astype(np.float32) / 255.0
+    return c
+
+
 class MglRenderer:
     """Render pymunk environments to the given moderngl context."""
 
@@ -310,6 +316,7 @@ def __init__(
         stated: StateDict,
         voffsets: tuple[int, ...] = (),
         hoffsets: tuple[int, ...] = (),
+        sc_color_opt: NDArray | None = None,
         sensor_fn: Callable[[StateDict], tuple[NDArray, NDArray]] | None = None,
     ) -> None:
         self._context = context
@@ -326,6 +333,11 @@ def __init__(
             self._range_min = y_range
             self._circle_scaling = screen_height / y_range * 2
 
+        if sc_color_opt is None:
+            self._sc_color = np.array([[254, 2, 162]])
+        else:
+            self._sc_color = sc_color_opt
+
         self._space = space
         circle_program = self._make_gl_program(
             vertex_shader=_CIRCLE_VERTEX_SHADER,
@@ -343,7 +355,7 @@ def __init__(
             scales=scales,
             colors=colors,
         )
-        points, scales, colors = _collect_circles(
+        points, scales, _ = _collect_circles(
             space.shaped.static_circle,
             stated.static_circle,
             self._circle_scaling,
@@ -353,7 +365,7 @@ def __init__(
             program=circle_program,
             points=points,
             scales=scales,
-            colors=colors,
+            colors=_get_sc_color(self._sc_color, stated.static_circle),
         )
         static_segment_program = self._make_gl_program(
             vertex_shader=_LINE_VERTEX_SHADER,
@@ -469,12 +481,15 @@ def render(
         circle_colors = self._get_colors(circle_colors_default, circle_colors)
         if self._circles.update(circle_points, circle_scale, circle_colors):
             self._circles.render()
-        sc_points, sc_scale, sc_colors_default = _collect_circles(
+        sc_points, sc_scale, _ = _collect_circles(
             self._space.shaped.static_circle,
             stated.static_circle,
             self._circle_scaling,
         )
-        sc_colors = self._get_colors(sc_colors_default, sc_colors)
+        sc_colors = self._get_colors(
+            _get_sc_color(self._sc_color, stated.static_circle),
+            sc_colors,
+        )
         if self._static_circles.update(sc_points, sc_scale, sc_colors):
             self._static_circles.render()
         if self._sensors is not None and self._collect_sensors is not None:
@@ -497,6 +512,7 @@ def __init__(
         y_range: float,
         space: Space,
         stated: StateDict,
+        food_color: NDArray,
         figsize: tuple[float, float] | None = None,
         voffsets: tuple[int, ...] = (),
         hoffsets: tuple[int, ...] = (),
@@ -528,6 +544,7 @@ def __init__(
             stated=stated,
             voffsets=voffsets,
             hoffsets=hoffsets,
+            sc_color_opt=food_color,
             sensor_fn=sensor_fn,
         )
 
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index cf2e6987..b945c5e9 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -38,6 +38,8 @@ class CfConfig:
     food_num_fn: Union[str, Tuple[str, ...]] = "constant"
     food_loc_fn: Union[str, Tuple[str, ...]] = "gaussian"
     agent_loc_fn: Union[str, Tuple[str, ...]] = "uniform"
+    food_energy_coef: Tuple[float, ...] = (1.0,)
+    food_color: Tuple[Tuple[int, int, int, int], ...] = ((254, 2, 162, 255),)
     xlim: Tuple[float, float] = (0.0, 200.0)
     ylim: Tuple[float, float] = (0.0, 200.0)
     env_radius: float = 120.0
@@ -196,15 +198,23 @@ class SavedPhysicsState:
     circle_is_active: jax.Array
     static_circle_axy: jax.Array
     static_circle_is_active: jax.Array
+    static_circle_label: jax.Array
 
     @staticmethod
     def load(path: Path) -> Self:
         npzfile = np.load(path)
+        static_circle_is_active=jnp.array(npzfile["static_circle_is_active"])
+        # For backward compatibility
+        if "static_circle_label" in npzfile:
+            static_circle_label = jnp.array(npzfile["static_circle_label"])
+        else:
+            static_circle_label = jnp.zeros(static_circle_is_active.shape[0], dtype=jnp.uint8)
         return SavedPhysicsState(
             circle_axy=jnp.array(npzfile["circle_axy"]),
             circle_is_active=jnp.array(npzfile["circle_is_active"]),
             static_circle_axy=jnp.array(npzfile["static_circle_axy"]),
-            static_circle_is_active=jnp.array(npzfile["static_circle_is_active"]),
+            static_circle_is_active=static_circle_is_active,
+            static_circle_label=static_circle_label,
         )
 
     def set_by_index(self, i: int, phys: StateDict) -> StateDict:
@@ -221,6 +231,10 @@ def set_by_index(self, i: int, phys: StateDict) -> StateDict:
             "static_circle.is_active",
             self.static_circle_is_active[i],
         )
+        phys = phys.nested_replace(
+            "static_circle.label",
+            self.static_circle_label[i],
+        )
         return phys
 
 
diff --git a/tests/test_observe.py b/tests/test_observe.py
index 500d8b2a..4f73f463 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -11,6 +11,7 @@
     CFState,
     CircleForaging,
     _observe_closest,
+    _observe_closest_with_food_labels,
     get_sensor_obs,
 )
 
@@ -56,38 +57,83 @@ def reset_env(key: chex.PRNGKey) -> tuple[CircleForaging, CFState, TimeStep[CFOb
     return typing.cast(CircleForaging, env), state, timestep
 
 
+def reset_multifood_env(
+    key: chex.PRNGKey,
+) -> tuple[CircleForaging, CFState, TimeStep[CFObs]]:
+    #   O x
+    # O x O x  (O: agent, x: food)
+    env = make(
+        "CircleForaging-v0",
+        env_shape="square",
+        n_max_agents=N_MAX_AGENTS,
+        n_initial_agents=3,
+        agent_loc_fn=(
+            "periodic",
+            [40.0, 60.0],
+            [60.0, 90.0],
+            [80.0, 60.0],
+        ),
+        n_food_sources=3,
+        food_loc_fn=[
+            ("periodic", [60.0, 60.0]),  # 0
+            ("periodic", [80.0, 90.0]),  # 1
+            ("periodic", [100.0, 60.0]),  # 2
+        ],
+        food_num_fn=[
+            ("constant", 1),
+            ("constant", 1),
+            ("constant", 1),
+        ],
+        agent_radius=AGENT_RADIUS,
+        food_radius=FOOD_RADIUS,
+    )
+    state, timestep = env.reset(key)
+    return typing.cast(CircleForaging, env), state, timestep
+
+
 def test_observe_closest(key: chex.PRNGKey) -> None:
     env, state, _ = reset_env(key)
-    obs = _observe_closest(
-        env._physics.shaped,
-        jnp.array([40.0, 10.0]),
-        jnp.array([40.0, 30.0]),
-        state.physics,
-    )
+
+    def observe(p1: jax.Array, p2: jax.Array) -> jax.Array:
+        return _observe_closest(
+            env._physics.shaped,
+            jnp.array(p1),
+            jnp.array(p2),
+            state.physics,
+        )
+
+    obs = observe([40.0, 10.0], [40.0, 30.0])
     chex.assert_trees_all_close(obs, jnp.ones(3) * -1)
-    obs = _observe_closest(
-        env._physics.shaped,
-        jnp.array([40.0, 10.0]),
-        jnp.array([40.0, 110.0]),
-        state.physics,
-    )
+    obs = observe([40.0, 10.0], [40.0, 110.0])
     chex.assert_trees_all_close(obs, jnp.array([0.6, -1.0, -1.0]))
-    obs = _observe_closest(
-        env._physics.shaped,
-        jnp.array([60.0, 10.0]),
-        jnp.array([60.0, 110.0]),
-        state.physics,
-    )
+    obs = observe([60.0, 10.0], [60.0, 110.0])
     chex.assert_trees_all_close(obs, jnp.array([-1.0, 0.54, -1.0]))
-    obs = _observe_closest(
-        env._physics.shaped,
-        jnp.array([130.0, 60.0]),
-        jnp.array([230.0, 60.0]),
-        state.physics,
-    )
+    obs = observe([130.0, 60.0], [230.0, 60.0])
     chex.assert_trees_all_close(obs, jnp.array([-1.0, -1.0, 0.3]))
 
 
+def test_observe_closest_with_foodlabels(key: chex.PRNGKey) -> None:
+    env, state, _ = reset_multifood_env(key)
+
+    def observe(p1: jax.Array, p2: jax.Array) -> jax.Array:
+        return _observe_closest_with_food_labels(
+            3,
+            env._physics.shaped,
+            jnp.array(p1),
+            jnp.array(p2),
+            state.physics,
+        )
+
+    obs = observe([40.0, 10.0], [40.0, 110.0])
+    chex.assert_trees_all_close(obs, jnp.array([0.6, -1.0, -1.0, -1.0, -1.0]))
+    obs = observe([60.0, 10.0], [60.0, 110.0])
+    chex.assert_trees_all_close(obs, jnp.array([-1.0, 0.54, -1.0, -1.0, -1.0]))
+    obs = observe([100.0, 10.0], [100.0, 110.0])
+    chex.assert_trees_all_close(obs, jnp.array([-1.0, -1.0, -1.0, 0.54, -1.0]))
+    obs = observe([100.0, 90.0], [0.0, 90.0])
+    chex.assert_trees_all_close(obs, jnp.array([-1.0, -1.0, 0.84, -1.0, -1.0]))
+
+
 def test_sensor_obs(key: chex.PRNGKey) -> None:
     env, state, _ = reset_env(key)
     sensor_obs = get_sensor_obs(
@@ -95,6 +141,7 @@ def test_sensor_obs(key: chex.PRNGKey) -> None:
         3,
         (-90, 90),
         100.0,
+        None,
         state.physics,
     )
     chex.assert_shape(sensor_obs, (30, 3))
@@ -132,6 +179,40 @@ def test_sensor_obs(key: chex.PRNGKey) -> None:
     )
 
 
+def test_sensor_obs_with_foodlabels(key: chex.PRNGKey) -> None:
+    env, state, _ = reset_multifood_env(key)
+    sensor_obs = get_sensor_obs(
+        env._physics.shaped,
+        3,
+        (-90, 90),
+        100.0,
+        3,
+        state.physics,
+    )
+    chex.assert_shape(sensor_obs, (30, 5))
+    # Food 0 is to the right/left
+    chex.assert_trees_all_close(
+        sensor_obs[0],
+        sensor_obs[8],
+        jnp.array([-1.0, 0.94, -1.0, -1.0, -1.0]),
+    )
+    # Food 1 is to the right
+    chex.assert_trees_all_close(
+        sensor_obs[3],
+        jnp.array([-1.0, -1.0, 0.94, -1.0, -1.0]),
+    )
+    # Food 1 is above
+    chex.assert_trees_all_close(
+        sensor_obs[7],
+        jnp.array([-1.0, -1.0, 0.84, -1.0, -1.0]),
+    )
+    # Food 2 is to the right
+    chex.assert_trees_all_close(
+        sensor_obs[6],
+        jnp.array([-1.0, -1.0, -1.0, 0.94, -1.0]),
+    )
+
+
 def test_encount_and_collision(key: chex.PRNGKey) -> None:
     #     x
     #   O x←3

From 70e3a981b4aa71bffc2f181ab7be639eca1e78b8 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 10 Feb 2024 15:11:34 +0900
Subject: [PATCH 248/337] [WIP] Smell

---
 src/emevo/environments/cf_with_smell.py | 39 +++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 src/emevo/environments/cf_with_smell.py

diff --git a/src/emevo/environments/cf_with_smell.py b/src/emevo/environments/cf_with_smell.py
new file mode 100644
index 00000000..91eaeef1
--- /dev/null
+++ b/src/emevo/environments/cf_with_smell.py
@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Literal, NamedTuple, Union
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+from jax.typing import ArrayLike
+
+from emevo.environments.circle_foraging import CircleForaging
+
+
+class CFSObs(NamedTuple):
+    """Observation of an agent with smell."""
+
+    sensor: jax.Array
+    collision: jax.Array
+    velocity: jax.Array
+    angle: jax.Array
+    angular_velocity: jax.Array
+    energy: jax.Array
+    smell: jax.Array
+
+    def as_array(self) -> jax.Array:
+        return jnp.concatenate(
+            (
+                self.sensor.reshape(self.sensor.shape[0], -1),
+                self.collision,
+                self.velocity,
+                jnp.expand_dims(self.angle, axis=1),
+                jnp.expand_dims(self.angular_velocity, axis=1),
+                jnp.expand_dims(self.energy, axis=1),
+            ),
+            axis=1,
+        )
+
+
+class CircleForagingWithSmell(CircleForaging):
+    pass

From 47cb3446c63c28740c3cc7161376e9336b8b2c35 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 10 Feb 2024 18:20:06 +0900
Subject: [PATCH 249/337] Fix collision with food labels

---
 src/emevo/environments/circle_foraging.py | 33 +++++++++--------
 tests/test_observe.py                     | 44 +++++++++++++++++++++++
 2 files changed, 62 insertions(+), 15 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 0790e947..2e3b303c 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -468,17 +468,6 @@ def __init__(
         self._agent_indices = jnp.arange(n_max_agents)
         self._food_indices = jnp.arange(n_max_foods)
         self._n_physics_iter = n_physics_iter
-        # Spaces
-        self.act_space = BoxSpace(low=min_force, high=max_force, shape=(2,))
-        self.obs_space = NamedTupleSpace(
-            CFObs,
-            sensor=BoxSpace(low=0.0, high=1.0, shape=(n_agent_sensors, N_OBJECTS)),
-            collision=BoxSpace(low=0.0, high=1.0, shape=(N_OBJECTS,)),
-            velocity=BoxSpace(low=-MAX_VELOCITY, high=MAX_VELOCITY, shape=(2,)),
-            angle=BoxSpace(low=-2 * np.pi, high=2 * np.pi, shape=()),
-            angular_velocity=BoxSpace(low=-np.pi / 10, high=np.pi / 10, shape=()),
-            energy=BoxSpace(low=0.0, high=energy_capacity, shape=()),
-        )
         # Obs
         self._n_sensors = n_agent_sensors
         # Some cached constants
@@ -594,10 +583,11 @@ def food_collision_with_labels(
             ) -> jax.Array:
                 onehot = jax.nn.one_hot(label, self._n_food_sources)  # (FOOD, LABEL)
                 expanded_c2sc = jnp.expand_dims(c2sc, axis=2)  # (AGENT, FOOD, 1)
-                expanded_onehot = jnp.expand_dims(onehot, axis=2)  # (1, FOOD, LABEL)
+                expanded_onehot = jnp.expand_dims(onehot, axis=0)  # (1, FOOD, LABEL)
                 return jnp.max(expanded_c2sc * expanded_onehot, axis=1)
 
             self._food_collision = food_collision_with_labels
+            self._n_obj = N_OBJECTS + self._n_food_sources - 1
 
         else:
             self._sensor_obs = jax.jit(
@@ -612,6 +602,19 @@ def food_collision_with_labels(
             )
 
             self._food_collision = lambda c2sc, _: jnp.max(c2sc, axis=1, keepdims=True)
+            self._n_obj = N_OBJECTS
+
+        # Spaces
+        self.act_space = BoxSpace(low=min_force, high=max_force, shape=(2,))
+        self.obs_space = NamedTupleSpace(
+            CFObs,
+            sensor=BoxSpace(low=0.0, high=1.0, shape=(n_agent_sensors, self._n_obj)),
+            collision=BoxSpace(low=0.0, high=1.0, shape=(self._n_obj,)),
+            velocity=BoxSpace(low=-MAX_VELOCITY, high=MAX_VELOCITY, shape=(2,)),
+            angle=BoxSpace(low=-2 * np.pi, high=2 * np.pi, shape=()),
+            angular_velocity=BoxSpace(low=-np.pi / 10, high=np.pi / 10, shape=()),
+            energy=BoxSpace(low=0.0, high=energy_capacity, shape=()),
+        )
 
         # For visualization
         self._food_color = np.array(list(food_color))
@@ -716,7 +719,7 @@ def step(
         c2sc = self._physics.get_contact_mat("circle", "static_circle", contacts)
         seg2c = self._physics.get_contact_mat("segment", "circle", contacts)
         food_collision = self._food_collision(c2sc, stated.static_circle.label)
-        collision = jnp.stack(
+        collision = jnp.concatenate(
             (
                 jnp.max(c2c, axis=1, keepdims=True),  # (N, 1)
                 food_collision,  # (N, N_LABELS)
@@ -749,7 +752,7 @@ def step(
         )
         # Construct obs
         obs = CFObs(
-            sensor=sensor_obs.reshape(-1, self._n_sensors, 3),
+            sensor=sensor_obs.reshape(-1, self._n_sensors, self._n_obj),
             collision=collision,
             angle=stated.circle.p.angle,
             velocity=stated.circle.v.xy,
@@ -866,7 +869,7 @@ def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
         )
         sensor_obs = self._sensor_obs(stated=physics)
         obs = CFObs(
-            sensor=sensor_obs.reshape(-1, self._n_sensors, N_OBJECTS),
+            sensor=sensor_obs.reshape(-1, self._n_sensors, self._n_obj),
             collision=jnp.zeros((N, N_OBJECTS), dtype=bool),
             angle=physics.circle.p.angle,
             velocity=physics.circle.v.xy,
diff --git a/tests/test_observe.py b/tests/test_observe.py
index 4f73f463..29c64686 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -86,6 +86,7 @@ def reset_multifood_env(
         ],
         agent_radius=AGENT_RADIUS,
         food_radius=FOOD_RADIUS,
+        observe_food_label=True,
     )
     state, timestep = env.reset(key)
     return typing.cast(CircleForaging, env), state, timestep
@@ -253,6 +254,49 @@ def test_encount_and_collision(key: chex.PRNGKey) -> None:
     assert n_iter < 99
 
 
+def test_collision_with_foodlabels(key: chex.PRNGKey) -> None:
+    #   O->x
+    # O->x O->x
+    env, state, _ = reset_multifood_env(key)
+    step = jax.jit(env.step)
+    # Rotate agent to right
+    act1 = jnp.zeros((10, 2)).at[:3, 0].set(20)
+    while True:
+        state, ts = step(state, act1)
+        assert jnp.all(jnp.logical_not(ts.encount))
+        if state.physics.circle.p.angle[0] <= jnp.pi * 1.51:
+            break
+
+    # Move it to right
+    act2 = act1.at[:3, 1].set(20.0)
+    n_iter = 0
+    for _ in range(100):
+        p = state.physics.circle.p.xy[:3]
+        state, ts = step(state, act2)
+
+        to_food = jnp.linalg.norm(
+            p - jnp.array([[60.0, 60.0], [80.0, 90.0], [100.0, 60.0]]),
+            axis=1,
+        )
+        if jnp.any(ts.obs.collision):
+            assert jnp.all(to_food <= AGENT_RADIUS + FOOD_RADIUS + 0.1)
+            chex.assert_trees_all_close(
+                ts.obs.collision[:3],
+                jnp.array(
+                    [
+                        [0.0, 1.0, 0.0, 0.0, 0.0],
+                        [0.0, 0.0, 1.0, 0.0, 0.0],
+                        [0.0, 0.0, 0.0, 1.0, 0.0],
+                    ]
+                ),
+            )
+            break
+
+        n_iter += 1
+
+    assert n_iter < 99
+
+
 def test_asarray(key: chex.PRNGKey) -> None:
     env, _, timestep = reset_env(key)
     obs = timestep.obs.as_array()

From 41a43e9c1e4973babb01f960aba5fc6897719ada Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 13 Feb 2024 00:13:30 +0900
Subject: [PATCH 250/337] Smell

---
 notebooks/diffusion.ipynb                 | 216 ++++++++++++++++++++++
 requirements/jupyter.in                   |   1 +
 src/emevo/environments/__init__.py        |   7 +
 src/emevo/environments/cf_with_smell.py   | 121 +++++++++++-
 src/emevo/environments/circle_foraging.py |   5 +
 src/emevo/environments/moderngl_vis.py    |   9 +-
 tests/test_observe.py                     |   4 +-
 tests/test_smell.py                       | 153 +++++++++++++++
 8 files changed, 507 insertions(+), 9 deletions(-)
 create mode 100644 notebooks/diffusion.ipynb
 create mode 100644 tests/test_smell.py

diff --git a/notebooks/diffusion.ipynb b/notebooks/diffusion.ipynb
new file mode 100644
index 00000000..888b4785
--- /dev/null
+++ b/notebooks/diffusion.ipynb
@@ -0,0 +1,216 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "4a269b9a-0b0e-4008-9d7d-c1033b09d61e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import celluloid\n",
+    "import ipywidgets as widgets\n",
+    "import numpy as np\n",
+    "from celluloid import Camera\n",
+    "from IPython.display import HTML\n",
+    "from matplotlib import colors as mc\n",
+    "from matplotlib import pyplot as plt\n",
+    "from matplotlib.lines import Line2D"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "2032dafb-e58c-4975-8e23-cbbbbad666a3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7ff8420d2650>]"
+      ]
+     },
+     "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": [
+    "fig, ax = plt.subplots()\n",
+    "x = np.linspace(0, 400, 100)\n",
+    "k = 0.01\n",
+    "ax.plot(x, np.exp(-k * x)) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "4323a167-11f4-4cf1-9295-aa1fa0a517e7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import jax.numpy as jnp\n",
+    "import jax"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "1d19087c-e9de-4802-ad7b-29294214cb37",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Array([[2., 1.],\n",
+       "       [2., 1.],\n",
+       "       [2., 1.],\n",
+       "       [2., 1.],\n",
+       "       [2., 1.],\n",
+       "       [2., 1.],\n",
+       "       [2., 1.],\n",
+       "       [2., 1.],\n",
+       "       [2., 1.],\n",
+       "       [2., 1.]], dtype=float32)"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "jnp.zeros((10, 2)) + jnp.array([[2, 1]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "aba16655-0d2f-460c-b3c9-99a04e2e517c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "f = jax.jit(lambda x: jnp.zeros((10, 2)).at[:, 1].add(x))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "3aec688e-d823-406b-a036-a1e6d6622c6d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Array([[ 0., 20.],\n",
+       "       [ 0., 20.],\n",
+       "       [ 0., 20.],\n",
+       "       [ 0., 20.],\n",
+       "       [ 0., 20.],\n",
+       "       [ 0., 20.],\n",
+       "       [ 0., 20.],\n",
+       "       [ 0., 20.],\n",
+       "       [ 0., 20.],\n",
+       "       [ 0., 20.]], dtype=float32)"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f(20)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b915000a-32f0-431a-b6bd-0d713a7672d7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a4ce2974-2d72-4657-b6ca-f790a0461208",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "8f0b58a8-1f98-4fc8-8d8b-b4547e70fb1b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7ff83bf940d0>]"
+      ]
+     },
+     "execution_count": 8,
+     "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": [
+    "fig, ax = plt.subplots()\n",
+    "x = np.linspace(0.1, 400, 100)\n",
+    "a = 10\n",
+    "b = 1\n",
+    "ax.plot(x, a * np.log(x) + b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "04de09f1-b4a4-43b9-abad-f936503c84cd",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "emevo-lab",
+   "language": "python",
+   "name": "emevo-lab"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/requirements/jupyter.in b/requirements/jupyter.in
index fe2b74c0..9c8766dd 100644
--- a/requirements/jupyter.in
+++ b/requirements/jupyter.in
@@ -1,5 +1,6 @@
 -r format.in
 -e .[analysis,video]
+celluloid
 ipympl
 ipywidgets
 jupyterlab
diff --git a/src/emevo/environments/__init__.py b/src/emevo/environments/__init__.py
index 6a8661a1..4e1b8b70 100644
--- a/src/emevo/environments/__init__.py
+++ b/src/emevo/environments/__init__.py
@@ -2,6 +2,7 @@
 """
 
 from emevo.environments.circle_foraging import CircleForaging
+from emevo.environments.cf_with_smell import CircleForagingWithSmell
 from emevo.environments.registry import register
 
 register(
@@ -9,3 +10,9 @@
     CircleForaging,
     "Phyjax2d circle foraging environment",
 )
+
+register(
+    "CircleForaging-v1",
+    CircleForagingWithSmell,
+    "Phyjax2d circle foraging environment",
+)
diff --git a/src/emevo/environments/cf_with_smell.py b/src/emevo/environments/cf_with_smell.py
index 91eaeef1..15f6608e 100644
--- a/src/emevo/environments/cf_with_smell.py
+++ b/src/emevo/environments/cf_with_smell.py
@@ -1,13 +1,16 @@
 from __future__ import annotations
 
-from typing import Any, Callable, Literal, NamedTuple, Union
+from typing import NamedTuple
 
+import chex
 import jax
 import jax.numpy as jnp
-import numpy as np
 from jax.typing import ArrayLike
 
-from emevo.environments.circle_foraging import CircleForaging
+from emevo.env import TimeStep
+from emevo.environments.circle_foraging import CFObs, CFState, CircleForaging
+from emevo.environments.phyjax2d import State
+from emevo.spaces import BoxSpace, NamedTupleSpace
 
 
 class CFSObs(NamedTuple):
@@ -20,6 +23,7 @@ class CFSObs(NamedTuple):
     angular_velocity: jax.Array
     energy: jax.Array
     smell: jax.Array
+    smell_diff: jax.Array
 
     def as_array(self) -> jax.Array:
         return jnp.concatenate(
@@ -30,10 +34,119 @@ def as_array(self) -> jax.Array:
                 jnp.expand_dims(self.angle, axis=1),
                 jnp.expand_dims(self.angular_velocity, axis=1),
                 jnp.expand_dims(self.energy, axis=1),
+                self.smell,
+                self.smell_diff,
             ),
             axis=1,
         )
 
 
+def _as_cfsobs(obs: CFObs, smell: jax.Array, smell_diff: jax.Array) -> CFSObs:
+    return CFSObs(
+        sensor=obs.sensor,
+        collision=obs.collision,
+        angle=obs.angle,
+        velocity=obs.velocity,
+        angular_velocity=obs.angular_velocity,
+        energy=obs.energy,
+        smell=smell,
+        smell_diff=smell_diff,
+    )
+
+
+@chex.dataclass
+class CFSState(CFState):
+    smell: jax.Array
+
+
+def _as_cfsstate(state: CFState, smell: jax.Array) -> CFSState:
+    return CFSState(
+        physics=state.stated,
+        solver=state.solver,
+        food_num=state.food_num,
+        agent_loc=state.agent_loc,
+        food_loc=state.food_loc,
+        key=state.key,
+        step=state.step,
+        unique_id=state.unique_id,
+        status=state.status,
+        n_born_agents=state.n_born_agents,
+        smell=smell,
+    )
+
+
+def _compute_smell(
+    n_food_sources: int,
+    decay_factor: float,
+    sc_state: State,
+    sensor_xy: jax.Array,
+) -> jax.Array:
+    # Compute distance
+    dist = jnp.linalg.norm(sc_state.p.xy - sensor_xy.reshape(1, 2), axis=1)
+    smell = jnp.exp(-decay_factor * dist)
+    smell_masked = jnp.where(sc_state.is_active, smell, 0.0)
+    smell_per_source = jnp.zeros(n_food_sources).at[sc_state.label].add(smell_masked)
+    return smell_per_source
+
+
+_vmap_compute_smell = jax.vmap(_compute_smell, in_axes=(None, None, None, 0))
+
+
 class CircleForagingWithSmell(CircleForaging):
-    pass
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        space = self.obs_space
+
+        self.obs_space = NamedTupleSpace(
+            CFSObs,
+            sensor=space.spaces.sensor,  # type: ignore
+            collision=space.spaces.collision,  # type: ignore
+            velocity=space.spaces.velocity,  # type: ignore
+            angle=space.spaces.angle,  # type: ignore
+            angular_velocity=space.spaces.angular_velocity,  # type: ignore
+            energy=space.spaces.energy,  # type: ignore
+            smell=BoxSpace(
+                low=0.0,
+                high=float(self._n_max_foods),
+                shape=(self._n_food_sources,),
+            ),
+            smell_diff=BoxSpace(low=0.0, high=1.0, shape=(self._n_food_sources,)),
+        )
+
+    def step(  # type: ignore
+        self,
+        state: CFSState,
+        action: ArrayLike,
+    ) -> tuple[CFSState, TimeStep[CFSObs]]:
+        cf_state, ts = super().step(state, action)
+        sensor_xy = cf_state.physics.circle.p.xy.at[:, 1].add(self._agent_radius)
+        smell = _vmap_compute_smell(
+            self._n_food_sources,
+            self._smell_decay_factor,
+            cf_state.physics.static_circle,
+            sensor_xy,
+        )
+        smell_diff = smell - state.smell
+        state = _as_cfsstate(cf_state, smell)
+        obs = _as_cfsobs(ts.obs, smell, smell_diff)
+        return state, TimeStep(encount=ts.encount, obs=obs)
+
+    def reset(  # type: ignore
+        self,
+        key: chex.PRNGKey,
+    ) -> tuple[CFSState, TimeStep[CFSObs]]:
+        cf_state, ts = super().reset(key)
+        sensor_xy = cf_state.physics.circle.p.xy.at[:, 1].add(self._agent_radius)
+        smell = _vmap_compute_smell(
+            self._n_food_sources,
+            self._smell_decay_factor,
+            cf_state.physics.static_circle,
+            sensor_xy,
+        )
+        state = _as_cfsstate(cf_state, smell)
+        obs = _as_cfsobs(
+            ts.obs,
+            smell,
+            jnp.zeros((self.n_max_agents, self._n_food_sources)),
+        )
+        return state, TimeStep(encount=ts.encount, obs=obs)
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 2e3b303c..ba405d83 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -389,6 +389,8 @@ def __init__(
         n_position_iter: int = 2,
         n_physics_iter: int = 5,
         max_place_attempts: int = 10,
+        # Only for CircleForagingWithSmell, but placed here to keep config class simple
+        smell_decay_factor: float = 0.01,
     ) -> None:
         # Coordinate and range
         if env_shape == "square":
@@ -628,6 +630,9 @@ def food_collision_with_labels(
             )
         )
 
+        # Smell
+        self._smell_decay_factor = smell_decay_factor
+
     @staticmethod
     def _make_food_num_fn(
         food_num_fn: str | tuple | ReprNumFn,
diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index 6a5346e1..6a38b0ec 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -297,9 +297,12 @@ def _get_clip_ranges(lengthes: list[float]) -> list[tuple[float, float]]:
 
 
 def _get_sc_color(colors: NDArray, state: State) -> NDArray:
-    label = np.array(state.label)
-    c = colors[label].astype(np.float32) / 255.0
-    return c
+    # Clip labels to make it work when less number of colors are provided
+    label = np.clip(np.array(state.label), a_min=0, a_max=len(colors) - 1)
+    default_color = colors[label].astype(np.float32) / 255.0
+    inactive_color = np.ones_like(default_color)
+    is_active_expanded = np.expand_dims(state.is_active, axis=1)
+    return np.where(is_active_expanded, default_color, inactive_color)
 
 
 class MglRenderer:
diff --git a/tests/test_observe.py b/tests/test_observe.py
index 29c64686..13f3f3ec 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -95,7 +95,7 @@ def reset_multifood_env(
 def test_observe_closest(key: chex.PRNGKey) -> None:
     env, state, _ = reset_env(key)
 
-    def observe(p1: jax.Array, p2: jax.Array) -> jax.Array:
+    def observe(p1: list[float], p2: list[float]) -> jax.Array:
         return _observe_closest(
             env._physics.shaped,
             jnp.array(p1),
@@ -116,7 +116,7 @@ def observe(p1: jax.Array, p2: jax.Array) -> jax.Array:
 def test_observe_closest_with_foodlabels(key: chex.PRNGKey) -> None:
     env, state, _ = reset_multifood_env(key)
 
-    def observe(p1: jax.Array, p2: jax.Array) -> jax.Array:
+    def observe(p1: list[float], p2: list[float]) -> jax.Array:
         return _observe_closest_with_food_labels(
             3,
             env._physics.shaped,
diff --git a/tests/test_smell.py b/tests/test_smell.py
new file mode 100644
index 00000000..d7a7c3e5
--- /dev/null
+++ b/tests/test_smell.py
@@ -0,0 +1,153 @@
+import typing
+
+import chex
+import jax
+import jax.numpy as jnp
+import pytest
+
+from emevo import TimeStep, make
+from emevo.environments.cf_with_smell import (
+    CFSObs,
+    CFSState,
+    CircleForagingWithSmell,
+    _compute_smell,
+    _vmap_compute_smell,
+)
+
+N_MAX_AGENTS = 10
+AGENT_RADIUS = 10
+FOOD_RADIUS = 4
+
+
+@pytest.fixture
+def key() -> chex.PRNGKey:
+    return jax.random.PRNGKey(43)
+
+
+def reset_env(
+    key: chex.PRNGKey,
+) -> tuple[CircleForagingWithSmell, CFSState, TimeStep[CFSObs]]:
+    # 12   x x O
+    # 9  O x
+    # 6      O  (O: agent, x: food)
+    #    3 6 9 12
+    env = make(
+        "CircleForaging-v1",
+        env_shape="square",
+        n_max_agents=N_MAX_AGENTS,
+        n_initial_agents=3,
+        agent_loc_fn=(
+            "periodic",
+            [30.0, 90.0],
+            [90.0, 60.0],
+            [120.0, 120.0],
+        ),
+        food_loc_fn=(
+            "periodic",
+            [60.0, 90.0],
+            [60.0, 120.0],
+            [90.0, 120.0],
+        ),
+        food_num_fn=("constant", 3),
+        foodloc_interval=20,
+        agent_radius=AGENT_RADIUS,
+        food_radius=FOOD_RADIUS,
+    )
+    state, timestep = env.reset(key)
+    return typing.cast(CircleForagingWithSmell, env), state, timestep
+
+
+def reset_multifood_env(
+    key: chex.PRNGKey,
+) -> tuple[CircleForagingWithSmell, CFSState, TimeStep[CFSObs]]:
+    # 12   2 2 O
+    # 9  O 1
+    # 6      O  (O: agent, 1/2/3: food)
+    #    3 6 9 12
+    env = make(
+        "CircleForaging-v1",
+        env_shape="square",
+        n_max_agents=N_MAX_AGENTS,
+        n_initial_agents=3,
+        agent_loc_fn=(
+            "periodic",
+            [30.0, 90.0],
+            [90.0, 60.0],
+            [120.0, 120.0],
+        ),
+        n_food_sources=2,
+        food_loc_fn=[
+            ("periodic", [60.0, 90.0]),  # 0
+            ("periodic", [60.0, 120.0], [90.0, 120.0]),  # 1
+        ],
+        food_num_fn=[
+            ("constant", 1),
+            ("constant", 2),
+        ],
+        foodloc_interval=20,
+        agent_radius=AGENT_RADIUS,
+        food_radius=FOOD_RADIUS,
+    )
+    state, timestep = env.reset(key)
+    return typing.cast(CircleForagingWithSmell, env), state, timestep
+
+
+def test_smell1(key: chex.PRNGKey) -> None:
+    env, state, ts = reset_env(key)
+
+    smell = _compute_smell(1, 0.01, state.physics.static_circle, jnp.zeros(2))
+    chex.assert_trees_all_close(smell, jnp.array([0.8235769]))
+    chex.assert_shape(state.smell, (N_MAX_AGENTS, 1))
+
+    chex.assert_trees_all_close(
+        state.smell[:3].ravel(),
+        jnp.array([1.95746815744733, 1.8619878481494374, 1.7593938269724911]),
+    )
+
+    chex.assert_shape(ts.obs.smell_diff, (N_MAX_AGENTS, 1))
+    chex.assert_trees_all_close(ts.obs.smell_diff, jnp.zeros((N_MAX_AGENTS, 1)))
+
+    _, ts = env.step(state, jnp.zeros((N_MAX_AGENTS, 2)).at[:3, 1].set(20.0))
+
+    chex.assert_shape(ts.obs.smell_diff, (N_MAX_AGENTS, 1))
+    sd = ts.obs.smell_diff[:3, 0]
+    assert (sd[0] > 0.0).item()  # Get closer
+    assert (sd[1] > 0.0).item()
+    assert (sd[2] < 0.0).item()
+
+
+def test_smell2(key: chex.PRNGKey) -> None:
+    env, state, ts = reset_multifood_env(key)
+
+    smell = _compute_smell(2, 0.01, state.physics.static_circle, jnp.zeros(2))
+    chex.assert_trees_all_close(
+        smell,
+        jnp.array([0.33903043982484377, 0.4845465481658833]),
+    )
+    chex.assert_shape(state.smell, (N_MAX_AGENTS, 2))
+
+    chex.assert_trees_all_close(
+        state.smell[:3],
+        jnp.array(
+            [
+                [0.7288934141100246, 1.2285747433373053],
+                [0.6972891342043375, 1.1646987139451],
+                [0.48621213667943447, 1.2731816902930566],
+            ]
+        ),
+    )
+    chex.assert_shape(ts.obs.smell_diff, (N_MAX_AGENTS, 2))
+    chex.assert_trees_all_close(ts.obs.smell_diff, jnp.zeros((N_MAX_AGENTS, 2)))
+
+    _, ts = env.step(state, jnp.zeros((N_MAX_AGENTS, 2)).at[:3, 1].set(20.0))
+
+    chex.assert_shape(ts.obs.smell_diff, (N_MAX_AGENTS, 2))
+    sd1 = ts.obs.smell_diff[:3, 0]
+    assert (sd1[0] < 0.0).item()  # Get closer
+    assert (sd1[1] > 0.0).item()
+    assert (sd1[2] < 0.0).item()
+
+    sd2 = ts.obs.smell_diff[:3, 1]
+    assert (sd2[0] > 0.0).item()  # Get closer
+    assert (sd2[1] > 0.0).item()
+    assert (sd2[2] < 0.0).item()

From fac98be91d44aef17911cc309396beb1f9aa9d6f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 13 Feb 2024 00:28:13 +0900
Subject: [PATCH 251/337] Start implementing cfs_as_evo

---
 experiments/cf_asexual_evo.py |   3 +-
 experiments/cfs_as_evo.py     | 618 ++++++++++++++++++++++++++++++++++
 2 files changed, 619 insertions(+), 2 deletions(-)
 create mode 100644 experiments/cfs_as_evo.py

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 993a0320..a0d12f81 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -1,5 +1,4 @@
-"""Asexual reward
- evolution with Circle Foraging"""
+"""Asexual reward evolution with Circle Foraging"""
 import dataclasses
 import enum
 import json
diff --git a/experiments/cfs_as_evo.py b/experiments/cfs_as_evo.py
new file mode 100644
index 00000000..55c7e6c9
--- /dev/null
+++ b/experiments/cfs_as_evo.py
@@ -0,0 +1,618 @@
+"""[WIP] Asexual reward evolution with CircleForagingWithSmell"""
+import dataclasses
+import enum
+import json
+from pathlib import Path
+from typing import Optional, cast
+
+import chex
+import equinox as eqx
+import jax
+import jax.numpy as jnp
+import numpy as np
+import optax
+import typer
+from serde import toml
+
+from emevo import Env
+from emevo import birth_and_death as bd
+from emevo import genetic_ops as gops
+from emevo import make
+from emevo.env import ObsProtocol as Obs
+from emevo.env import StateProtocol as State
+from emevo.eqx_utils import get_slice
+from emevo.eqx_utils import where as eqx_where
+from emevo.exp_utils import (
+    BDConfig,
+    CfConfig,
+    GopsConfig,
+    Log,
+    Logger,
+    LogMode,
+    SavedPhysicsState,
+    SavedProfile,
+)
+from emevo.reward_fn import (
+    ExponentialReward,
+    LinearReward,
+    RewardFn,
+    SigmoidReward,
+    SigmoidReward_01,
+    SinhReward,
+    mutate_reward_fn,
+    serialize_weight,
+)
+from emevo.rl.ppo_normal import (
+    NormalPPONet,
+    Rollout,
+    vmap_apply,
+    vmap_batch,
+    vmap_net,
+    vmap_update,
+    vmap_value,
+)
+from emevo.spaces import BoxSpace
+from emevo.visualizer import SaveVideoWrapper
+
+PROJECT_ROOT = Path(__file__).parent.parent
+
+
+class RewardKind(str, enum.Enum):
+    LINEAR = "linear"
+    EXPONENTIAL = "exponential"
+    SIGMOID = "sigmoid"
+    SIGMOID_01 = "sigmoid-01"
+    SINH = "sinh"
+
+
+@dataclasses.dataclass
+class RewardExtractor:
+    act_space: BoxSpace
+    act_coef: float
+    max_norm: jax.Array = dataclasses.field(init=False)
+
+    def __post_init__(self) -> None:
+        self.max_norm = jnp.sqrt(
+            jnp.sum(self.act_space.high**2, axis=-1, keepdims=True)
+        )
+
+    def normalize_action(self, action: jax.Array) -> jax.Array:
+        scaled = self.act_space.sigmoid_scale(action)
+        norm = jnp.sqrt(jnp.sum(scaled**2, axis=-1, keepdims=True))
+        return norm / self.max_norm
+
+    def extract_linear(
+        self,
+        collision: jax.Array,
+        action: jax.Array,
+        energy: jax.Array,
+    ) -> jax.Array:
+        del energy
+        act_input = self.act_coef * self.normalize_action(action)
+        return jnp.concatenate((collision, act_input), axis=1)
+
+    def extract_sigmoid(
+        self,
+        collision: jax.Array,
+        action: jax.Array,
+        energy: jax.Array,
+    ) -> tuple[jax.Array, jax.Array]:
+        act_input = self.act_coef * self.normalize_action(action)
+        return jnp.concatenate((collision, act_input), axis=1), energy
+
+
+def linear_reward_serializer(w: jax.Array) -> dict[str, jax.Array]:
+    return serialize_weight(w, ["agent", "food", "wall", "action"])
+
+
+def exp_reward_serializer(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
+    w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    scale_dict = serialize_weight(
+        scale,
+        ["scale_agent", "scale_food", "scale_wall", "scale_action"],
+    )
+    return w_dict | scale_dict
+
+
+def sigmoid_reward_serializer(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
+    w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    alpha_dict = serialize_weight(
+        alpha,
+        ["alpha_agent", "alpha_food", "alpha_wall", "alpha_action"],
+    )
+    return w_dict | alpha_dict
+
+
+def exec_rollout(
+    state: State,
+    initial_obs: Obs,
+    env: Env,
+    network: NormalPPONet,
+    reward_fn: RewardFn,
+    hazard_fn: bd.HazardFunction,
+    birth_fn: bd.BirthFunction,
+    prng_key: jax.Array,
+    n_rollout_steps: int,
+) -> tuple[State, Rollout, Log, SavedPhysicsState, Obs, jax.Array]:
+    def step_rollout(
+        carried: tuple[State, Obs],
+        key: jax.Array,
+    ) -> tuple[tuple[State, Obs], tuple[Rollout, Log, SavedPhysicsState]]:
+        act_key, hazard_key, birth_key = jax.random.split(key, 3)
+        state_t, obs_t = carried
+        obs_t_array = obs_t.as_array()
+        net_out = vmap_apply(network, obs_t_array)
+        actions = net_out.policy().sample(seed=act_key)
+        state_t1, timestep = env.step(
+            state_t,
+            env.act_space.sigmoid_scale(actions),  # type: ignore
+        )
+        obs_t1 = timestep.obs
+        energy = state_t.status.energy
+        rewards = reward_fn(obs_t1.collision, actions, energy).reshape(-1, 1)
+        rollout = Rollout(
+            observations=obs_t_array,
+            actions=actions,
+            rewards=rewards,
+            terminations=jnp.zeros_like(rewards),
+            values=net_out.value,
+            means=net_out.mean,
+            logstds=net_out.logstd,
+        )
+        # Birth and death
+        death_prob = hazard_fn(state_t1.status.age, state_t1.status.energy)
+        dead = jax.random.bernoulli(hazard_key, p=death_prob)
+        state_t1d = env.deactivate(state_t1, dead)
+        birth_prob = birth_fn(state_t1d.status.age, state_t1d.status.energy)
+        possible_parents = jnp.logical_and(
+            jnp.logical_and(
+                jnp.logical_not(dead),
+                state.unique_id.is_active(),  # type: ignore
+            ),
+            jax.random.bernoulli(birth_key, p=birth_prob),
+        )
+        state_t1db, parents = env.activate(state_t1d, possible_parents)
+        log = Log(
+            dead=jnp.where(dead, state_t.unique_id.unique_id, -1),  # type: ignore
+            got_food=obs_t1.collision[:, 1],
+            parents=parents,
+            rewards=rewards.ravel(),
+            age=state_t1db.status.age,
+            energy=state_t1db.status.energy,
+            unique_id=state_t1db.unique_id.unique_id,
+        )
+        phys = state_t.physics  # type: ignore
+        phys_state = SavedPhysicsState(
+            circle_axy=phys.circle.p.into_axy(),
+            static_circle_axy=phys.static_circle.p.into_axy(),
+            circle_is_active=phys.circle.is_active,
+            static_circle_is_active=phys.static_circle.is_active,
+            static_circle_label=phys.static_circle.label,
+        )
+        return (state_t1db, obs_t1), (rollout, log, phys_state)
+
+    (state, obs), (rollout, log, phys_state) = jax.lax.scan(
+        step_rollout,
+        (state, initial_obs),
+        jax.random.split(prng_key, n_rollout_steps),
+    )
+    next_value = vmap_value(network, obs.as_array())
+    return state, rollout, log, phys_state, obs, next_value
+
+
+@eqx.filter_jit
+def epoch(
+    state: State,
+    initial_obs: Obs,
+    env: Env,
+    network: NormalPPONet,
+    reward_fn: RewardFn,
+    hazard_fn: bd.HazardFunction,
+    birth_fn: bd.BirthFunction,
+    prng_key: jax.Array,
+    n_rollout_steps: int,
+    gamma: float,
+    gae_lambda: float,
+    adam_update: optax.TransformUpdateFn,
+    opt_state: optax.OptState,
+    minibatch_size: int,
+    n_optim_epochs: int,
+) -> tuple[State, Obs, Log, SavedPhysicsState, optax.OptState, NormalPPONet]:
+    keys = jax.random.split(prng_key, env.n_max_agents + 1)
+    env_state, rollout, log, phys_state, obs, next_value = exec_rollout(
+        state,
+        initial_obs,
+        env,
+        network,
+        reward_fn,
+        hazard_fn,
+        birth_fn,
+        keys[0],
+        n_rollout_steps,
+    )
+    batch = vmap_batch(rollout, next_value, gamma, gae_lambda)
+    opt_state, pponet = vmap_update(
+        batch,
+        network,
+        adam_update,
+        opt_state,
+        keys[1:],
+        minibatch_size,
+        n_optim_epochs,
+        0.2,
+        0.0,
+    )
+    return env_state, obs, log, phys_state, opt_state, pponet
+
+
+def run_evolution(
+    *,
+    key: jax.Array,
+    env: Env,
+    n_initial_agents: int,
+    adam: optax.GradientTransformation,
+    gamma: float,
+    gae_lambda: float,
+    n_optim_epochs: int,
+    minibatch_size: int,
+    n_rollout_steps: int,
+    n_total_steps: int,
+    reward_fn: RewardFn,
+    hazard_fn: bd.HazardFunction,
+    birth_fn: bd.BirthFunction,
+    mutation: gops.Mutation,
+    xmax: float,
+    ymax: float,
+    logger: Logger,
+    debug_vis: bool,
+) -> None:
+    key, net_key, reset_key = jax.random.split(key, 3)
+    obs_space = env.obs_space.flatten()
+    input_size = np.prod(obs_space.shape)
+    act_size = np.prod(env.act_space.shape)
+
+    def initialize_net(key: chex.PRNGKey) -> NormalPPONet:
+        return vmap_net(
+            input_size,
+            64,
+            act_size,
+            jax.random.split(key, env.n_max_agents),
+        )
+
+    pponet = initialize_net(net_key)
+    adam_init, adam_update = adam
+
+    @eqx.filter_jit
+    def initialize_opt_state(net: eqx.Module) -> optax.OptState:
+        return jax.vmap(adam_init)(eqx.filter(net, eqx.is_array))
+
+    @eqx.filter_jit
+    def replace_net(
+        key: chex.PRNGKey,
+        flag: jax.Array,
+        pponet: NormalPPONet,
+        opt_state: optax.OptState,
+    ) -> tuple[NormalPPONet, optax.OptState]:
+        initialized = initialize_net(key)
+        pponet = eqx_where(flag, initialized, pponet)
+        opt_state = jax.tree_map(
+            lambda a, b: jnp.where(
+                jnp.expand_dims(flag, tuple(range(1, a.ndim))),
+                b,
+                a,
+            ),
+            opt_state,
+            initialize_opt_state(pponet),
+        )
+        return pponet, opt_state
+
+    opt_state = initialize_opt_state(pponet)
+    env_state, timestep = env.reset(reset_key)
+    obs = timestep.obs
+
+    if debug_vis:
+        visualizer = env.visualizer(env_state, figsize=(xmax * 2, ymax * 2))
+    else:
+        visualizer = None
+
+    for i in range(n_initial_agents):
+        logger.reward_fn_dict[i + 1] = get_slice(reward_fn, i)
+        logger.profile_dict[i + 1] = SavedProfile(0, 0, i + 1)
+
+    for i, key in enumerate(jax.random.split(key, n_total_steps // n_rollout_steps)):
+        epoch_key, init_key = jax.random.split(key)
+        env_state, obs, log, phys_state, opt_state, pponet = epoch(
+            env_state,
+            obs,
+            env,
+            pponet,
+            reward_fn,
+            hazard_fn,
+            birth_fn,
+            epoch_key,
+            n_rollout_steps,
+            gamma,
+            gae_lambda,
+            adam_update,
+            opt_state,
+            minibatch_size,
+            n_optim_epochs,
+        )
+
+        if visualizer is not None:
+            visualizer.render(env_state.physics)  # type: ignore
+            visualizer.show()
+        # Extinct?
+        n_active = jnp.sum(env_state.unique_id.is_active())  # type: ignore
+        if n_active == 0:
+            print(f"Extinct after {i + 1} epochs")
+            break
+
+        # Save network
+        log_with_step = log.with_step(i * n_rollout_steps)
+        log_death = log_with_step.filter_death()
+        logger.save_agents(pponet, log_death.dead, log_death.slots)
+        log_birth = log_with_step.filter_birth()
+        # Initialize network and adam state for new agents
+        is_new = jnp.zeros(env.n_max_agents, dtype=bool).at[log_birth.slots].set(True)
+        if jnp.any(is_new):
+            pponet, opt_state = replace_net(init_key, is_new, pponet, opt_state)
+
+        # Mutation
+        reward_fn = mutate_reward_fn(
+            key,
+            logger.reward_fn_dict,
+            reward_fn,
+            mutation,
+            log_birth.parents,
+            log_birth.unique_id,
+            log_birth.slots,
+        )
+        # Update profile
+        for step, uid, parent in zip(
+            log_birth.step,
+            log_birth.unique_id,
+            log_birth.parents,
+        ):
+            ui = uid.item()
+            logger.profile_dict[ui] = SavedProfile(step.item(), parent.item(), ui)
+
+        # Push log and physics state
+        logger.push_log(log_with_step.filter_active())
+        logger.push_physstate(phys_state)
+
+    # Save logs before exiting
+    logger.finalize()
+    is_active = env_state.unique_id.is_active()
+    logger.save_agents(
+        pponet,
+        env_state.unique_id.unique_id[is_active],
+        jnp.arange(len(is_active))[is_active],
+    )
+
+
+app = typer.Typer(pretty_exceptions_show_locals=False)
+
+
+@app.command()
+def evolve(
+    seed: int = 1,
+    n_agents: int = 20,
+    init_energy: float = 20.0,
+    action_cost: float = 0.0001,
+    mutation_prob: float = 0.2,
+    adam_lr: float = 3e-4,
+    adam_eps: float = 1e-7,
+    gamma: float = 0.999,
+    gae_lambda: float = 0.95,
+    n_optim_epochs: int = 10,
+    minibatch_size: int = 256,
+    n_rollout_steps: int = 1024,
+    n_total_steps: int = 1024 * 10000,
+    act_reward_coef: float = 0.001,
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
+    bdconfig_path: Path = PROJECT_ROOT / "config/bd/20230530-a035-e020.toml",
+    gopsconfig_path: Path = PROJECT_ROOT / "config/gops/20240111-mutation-0401.toml",
+    env_override: str = "",
+    birth_override: str = "",
+    hazard_override: str = "",
+    reward_fn: RewardKind = RewardKind.LINEAR,
+    logdir: Path = Path("./log"),
+    log_mode: LogMode = LogMode.FULL,
+    log_interval: int = 1000,
+    savestate_interval: int = 1000,
+    debug_vis: bool = False,
+) -> None:
+    # Load config
+    with cfconfig_path.open("r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+    with bdconfig_path.open("r") as f:
+        bdconfig = toml.from_toml(BDConfig, f.read())
+    with gopsconfig_path.open("r") as f:
+        gopsconfig = toml.from_toml(GopsConfig, f.read())
+
+    # Apply overrides
+    cfconfig.apply_override(env_override)
+    bdconfig.apply_birth_override(birth_override)
+    bdconfig.apply_hazard_override(hazard_override)
+
+    # Load models
+    birth_fn, hazard_fn = bdconfig.load_models()
+    mutation = gopsconfig.load_model()
+    # Override config
+    cfconfig.n_initial_agents = n_agents
+    cfconfig.init_energy = init_energy
+    cfconfig.force_energy_consumption = action_cost
+    gopsconfig.params["mutation_prob"] = mutation_prob
+    # Make env
+    env = make("CircleForaging-v1", **dataclasses.asdict(cfconfig))
+    key, reward_key = jax.random.split(jax.random.PRNGKey(seed))
+    reward_extracor = RewardExtractor(
+        act_space=env.act_space,  # type: ignore
+        act_coef=act_reward_coef,
+    )
+    common_rewardfn_args = {
+        "key": reward_key,
+        "n_agents": cfconfig.n_max_agents,
+        "n_weights": 4,
+        "std": gopsconfig.init_std,
+        "mean": gopsconfig.init_mean,
+    }
+    if reward_fn == RewardKind.LINEAR:
+        reward_fn_instance = LinearReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_linear,
+            serializer=linear_reward_serializer,
+        )
+    elif reward_fn == RewardKind.EXPONENTIAL:
+        reward_fn_instance = ExponentialReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_linear,
+            serializer=exp_reward_serializer,
+        )
+    elif reward_fn == RewardKind.SIGMOID:
+        reward_fn_instance = SigmoidReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=sigmoid_reward_serializer,
+        )
+    elif reward_fn == RewardKind.SIGMOID_01:
+        reward_fn_instance = SigmoidReward_01(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=sigmoid_reward_serializer,
+        )
+    elif reward_fn == RewardKind.SINH:
+        reward_fn_instance = SinhReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_linear,
+            serializer=linear_reward_serializer,
+        )
+    else:
+        raise ValueError(f"Invalid reward_fn {reward_fn}")
+
+    logger = Logger(
+        logdir=logdir,
+        mode=log_mode,
+        log_interval=log_interval,
+        savestate_interval=savestate_interval,
+    )
+    run_evolution(
+        key=key,
+        env=env,
+        n_initial_agents=n_agents,
+        adam=optax.adam(adam_lr, eps=adam_eps),
+        gamma=gamma,
+        gae_lambda=gae_lambda,
+        n_optim_epochs=n_optim_epochs,
+        minibatch_size=minibatch_size,
+        n_rollout_steps=n_rollout_steps,
+        n_total_steps=n_total_steps,
+        reward_fn=reward_fn_instance,
+        hazard_fn=hazard_fn,
+        birth_fn=birth_fn,
+        mutation=cast(gops.Mutation, mutation),
+        xmax=cfconfig.xlim[1],
+        ymax=cfconfig.ylim[1],
+        logger=logger,
+        debug_vis=debug_vis,
+    )
+
+
+@app.command()
+def replay(
+    physstate_path: Path,
+    backend: str = "pyglet",  # Use "headless" for headless rendering
+    videopath: Optional[Path] = None,
+    start: int = 0,
+    end: Optional[int] = None,
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
+    env_override: str = "",
+) -> None:
+    with cfconfig_path.open("r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+    # For speedup
+    cfconfig.n_initial_agents = 1
+    cfconfig.apply_override(env_override)
+    phys_state = SavedPhysicsState.load(physstate_path)
+    env = make("CircleForaging-v1", **dataclasses.asdict(cfconfig))
+    env_state, _ = env.reset(jax.random.PRNGKey(0))
+    end_index = end if end is not None else phys_state.circle_axy.shape[0]
+    visualizer = env.visualizer(
+        env_state,
+        figsize=(cfconfig.xlim[1] * 2, cfconfig.ylim[1] * 2),
+        backend=backend,
+    )
+    if videopath is not None:
+        visualizer = SaveVideoWrapper(visualizer, videopath, fps=60)
+    for i in range(start, end_index):
+        phys = phys_state.set_by_index(i, env_state.physics)
+        env_state = dataclasses.replace(env_state, physics=phys)
+        visualizer.render(env_state.physics)
+        visualizer.show()
+    visualizer.close()
+
+
+@app.command()
+def widget(
+    physstate_path: Path,
+    start: int = 0,
+    end: Optional[int] = None,
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
+    log_offset: int = 0,
+    log_path: Optional[Path] = None,
+    self_terminate: bool = False,
+    profile_and_rewards_path: Optional[Path] = None,
+    cm_fixed_minmax: str = "",
+    env_override: str = "",
+) -> None:
+    from emevo.analysis.qt_widget import CFEnvReplayWidget, start_widget
+
+    with cfconfig_path.open("r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+    # For speedup
+    cfconfig.n_initial_agents = 1
+    cfconfig.apply_override(env_override)
+    phys_state = SavedPhysicsState.load(physstate_path)
+    env = make("CircleForaging-v1", **dataclasses.asdict(cfconfig))
+    end = phys_state.circle_axy.shape[0] if end is None else end
+    if log_path is None:
+        log_ds = None
+        step_offset = 0
+    else:
+        import pyarrow.dataset as ds
+
+        log_ds = ds.dataset(log_path)
+        first_step = log_ds.scanner(columns=["step"]).head(1)["step"][0].as_py()
+        step_offset = first_step + log_offset
+
+    if profile_and_rewards_path is None:
+        profile_and_rewards = None
+    else:
+        import pyarrow.parquet as pq
+
+        profile_and_rewards = pq.read_table(profile_and_rewards_path)
+
+    if len(cm_fixed_minmax) > 0:
+        cm_fixed_minmax_dict = json.loads(cm_fixed_minmax)
+    else:
+        cm_fixed_minmax_dict = {}
+
+    start_widget(
+        CFEnvReplayWidget,
+        xlim=int(cfconfig.xlim[1]),
+        ylim=int(cfconfig.ylim[1]),
+        env=env,
+        saved_physics=phys_state,
+        start=start,
+        end=end,
+        log_ds=log_ds,
+        step_offset=step_offset,
+        self_terminate=self_terminate,
+        profile_and_rewards=profile_and_rewards,
+        cm_fixed_minmax=cm_fixed_minmax_dict,
+    )
+
+
+if __name__ == "__main__":
+    app()

From 539f78a4b534b55e0fc25db770f841f6f58cee57 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 13 Feb 2024 00:50:47 +0900
Subject: [PATCH 252/337] Reward mask

---
 experiments/cf_asexual_evo.py | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index a0d12f81..cd8d8a01 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -69,17 +69,21 @@ class RewardKind(str, enum.Enum):
 class RewardExtractor:
     act_space: BoxSpace
     act_coef: float
-    max_norm: jax.Array = dataclasses.field(init=False)
-
-    def __post_init__(self) -> None:
-        self.max_norm = jnp.sqrt(
+    mask: dataclasses.InitVar[str] = "1111"
+    _mask_array: jax.Array = dataclasses.field(init=False)
+    _max_norm: jax.Array = dataclasses.field(init=False)
+
+    def __post_init__(self, mask: str) -> None:
+        mask_array = jnp.array([x == "1" for x in mask])
+        self._mask_array = jnp.expand_dims(mask_array, axis=0)
+        self._max_norm = jnp.sqrt(
             jnp.sum(self.act_space.high**2, axis=-1, keepdims=True)
         )
 
     def normalize_action(self, action: jax.Array) -> jax.Array:
         scaled = self.act_space.sigmoid_scale(action)
         norm = jnp.sqrt(jnp.sum(scaled**2, axis=-1, keepdims=True))
-        return norm / self.max_norm
+        return norm / self._max_norm
 
     def extract_linear(
         self,
@@ -89,7 +93,7 @@ def extract_linear(
     ) -> jax.Array:
         del energy
         act_input = self.act_coef * self.normalize_action(action)
-        return jnp.concatenate((collision, act_input), axis=1)
+        return jnp.concatenate((collision, act_input), axis=1) * self._mask_array
 
     def extract_sigmoid(
         self,
@@ -98,7 +102,8 @@ def extract_sigmoid(
         energy: jax.Array,
     ) -> tuple[jax.Array, jax.Array]:
         act_input = self.act_coef * self.normalize_action(action)
-        return jnp.concatenate((collision, act_input), axis=1), energy
+        reward_input = jnp.concatenate((collision, act_input), axis=1)
+        return reward_input * self._mask_array, energy
 
 
 def linear_reward_serializer(w: jax.Array) -> dict[str, jax.Array]:
@@ -416,6 +421,7 @@ def evolve(
     env_override: str = "",
     birth_override: str = "",
     hazard_override: str = "",
+    reward_mask: str = "1111",
     reward_fn: RewardKind = RewardKind.LINEAR,
     logdir: Path = Path("./log"),
     log_mode: LogMode = LogMode.FULL,
@@ -450,6 +456,7 @@ def evolve(
     reward_extracor = RewardExtractor(
         act_space=env.act_space,  # type: ignore
         act_coef=act_reward_coef,
+        mask=reward_mask,
     )
     common_rewardfn_args = {
         "key": reward_key,

From 6ff9600f94724a2f8725a99c45185808417722f3 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 13 Feb 2024 16:13:55 +0900
Subject: [PATCH 253/337] Scale smell diff

---
 experiments/cfs_as_evo.py                 | 42 +++++++++++++++--------
 src/emevo/environments/cf_with_smell.py   | 33 +++++++++++++++---
 src/emevo/environments/circle_foraging.py |  4 +++
 src/emevo/exp_utils.py                    |  3 ++
 4 files changed, 63 insertions(+), 19 deletions(-)

diff --git a/experiments/cfs_as_evo.py b/experiments/cfs_as_evo.py
index 55c7e6c9..e1867263 100644
--- a/experiments/cfs_as_evo.py
+++ b/experiments/cfs_as_evo.py
@@ -69,56 +69,66 @@ class RewardKind(str, enum.Enum):
 class RewardExtractor:
     act_space: BoxSpace
     act_coef: float
-    max_norm: jax.Array = dataclasses.field(init=False)
-
-    def __post_init__(self) -> None:
-        self.max_norm = jnp.sqrt(
+    smell_coef: float
+    mask: dataclasses.InitVar[str] = "11111"
+    _mask_array: jax.Array = dataclasses.field(init=False)
+    _max_norm: jax.Array = dataclasses.field(init=False)
+
+    def __post_init__(self, mask: str) -> None:
+        mask_array = jnp.array([x == "1" for x in mask])
+        self._mask_array = jnp.expand_dims(mask_array, axis=0)
+        self._max_norm = jnp.sqrt(
             jnp.sum(self.act_space.high**2, axis=-1, keepdims=True)
         )
 
     def normalize_action(self, action: jax.Array) -> jax.Array:
         scaled = self.act_space.sigmoid_scale(action)
         norm = jnp.sqrt(jnp.sum(scaled**2, axis=-1, keepdims=True))
-        return norm / self.max_norm
+        return norm / self._max_norm
 
     def extract_linear(
         self,
         collision: jax.Array,
         action: jax.Array,
         energy: jax.Array,
+        smell: jax.Array,
     ) -> jax.Array:
         del energy
         act_input = self.act_coef * self.normalize_action(action)
-        return jnp.concatenate((collision, act_input), axis=1)
+        smell_input = self.smell_coef * smell
+        return jnp.concatenate((collision, act_input, smell_input), axis=1) * self._mask_array
 
     def extract_sigmoid(
         self,
         collision: jax.Array,
         action: jax.Array,
         energy: jax.Array,
+        smell: jax.Array,
     ) -> tuple[jax.Array, jax.Array]:
         act_input = self.act_coef * self.normalize_action(action)
-        return jnp.concatenate((collision, act_input), axis=1), energy
+        smell_input = self.smell_coef * smell
+        reward_input = jnp.concatenate((collision, act_input, smell_input), axis=1)
+        return reward_input * self._mask_array, energy
 
 
 def linear_reward_serializer(w: jax.Array) -> dict[str, jax.Array]:
-    return serialize_weight(w, ["agent", "food", "wall", "action"])
+    return serialize_weight(w, ["agent", "food", "wall", "action", "smell"])
 
 
 def exp_reward_serializer(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
-    w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action", "w_smell"])
     scale_dict = serialize_weight(
         scale,
-        ["scale_agent", "scale_food", "scale_wall", "scale_action"],
+        ["scale_agent", "scale_food", "scale_wall", "scale_action", "alpha_smell"],
     )
     return w_dict | scale_dict
 
 
 def sigmoid_reward_serializer(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
-    w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action", "w_smell"])
     alpha_dict = serialize_weight(
         alpha,
-        ["alpha_agent", "alpha_food", "alpha_wall", "alpha_action"],
+        ["alpha_agent", "alpha_food", "alpha_wall", "alpha_action", "alpha_smell"],
     )
     return w_dict | alpha_dict
 
@@ -149,7 +159,8 @@ def step_rollout(
         )
         obs_t1 = timestep.obs
         energy = state_t.status.energy
-        rewards = reward_fn(obs_t1.collision, actions, energy).reshape(-1, 1)
+        smell = state_t.smell  # type: ignore
+        rewards = reward_fn(obs_t1.collision, actions, energy, smell).reshape(-1, 1)
         rollout = Rollout(
             observations=obs_t_array,
             actions=actions,
@@ -416,6 +427,7 @@ def evolve(
     env_override: str = "",
     birth_override: str = "",
     hazard_override: str = "",
+    reward_mask: str = "11111",
     reward_fn: RewardKind = RewardKind.LINEAR,
     logdir: Path = Path("./log"),
     log_mode: LogMode = LogMode.FULL,
@@ -450,11 +462,13 @@ def evolve(
     reward_extracor = RewardExtractor(
         act_space=env.act_space,  # type: ignore
         act_coef=act_reward_coef,
+        smell_coef=1.0 / cfconfig.n_max_foods,
+        mask=reward_mask,
     )
     common_rewardfn_args = {
         "key": reward_key,
         "n_agents": cfconfig.n_max_agents,
-        "n_weights": 4,
+        "n_weights": 5,
         "std": gopsconfig.init_std,
         "mean": gopsconfig.init_mean,
     }
diff --git a/src/emevo/environments/cf_with_smell.py b/src/emevo/environments/cf_with_smell.py
index 15f6608e..af90b939 100644
--- a/src/emevo/environments/cf_with_smell.py
+++ b/src/emevo/environments/cf_with_smell.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import NamedTuple
+from dataclasses import replace
+from typing import NamedTuple, overload
 
 import chex
 import jax
@@ -110,7 +111,11 @@ def __init__(self, *args, **kwargs) -> None:
                 high=float(self._n_max_foods),
                 shape=(self._n_food_sources,),
             ),
-            smell_diff=BoxSpace(low=0.0, high=1.0, shape=(self._n_food_sources,)),
+            smell_diff=BoxSpace(
+                low=-self._smell_diff_max,
+                high=self._smell_diff_max,
+                shape=(self._n_food_sources,),
+            ),
         )
 
     def step(  # type: ignore
@@ -126,7 +131,11 @@ def step(  # type: ignore
             cf_state.physics.static_circle,
             sensor_xy,
         )
-        smell_diff = smell - state.smell
+        smell_diff = jnp.clip(
+            (smell - state.smell) * self._smell_diff_coef,
+            a_min=-self._smell_diff_max,
+            a_max=self._smell_diff_max,
+        )
         state = _as_cfsstate(cf_state, smell)
         obs = _as_cfsobs(ts.obs, smell, smell_diff)
         return state, TimeStep(encount=ts.encount, obs=obs)
@@ -136,12 +145,11 @@ def reset(  # type: ignore
         key: chex.PRNGKey,
     ) -> tuple[CFSState, TimeStep[CFSObs]]:
         cf_state, ts = super().reset(key)
-        sensor_xy = cf_state.physics.circle.p.xy.at[:, 1].add(self._agent_radius)
         smell = _vmap_compute_smell(
             self._n_food_sources,
             self._smell_decay_factor,
             cf_state.physics.static_circle,
-            sensor_xy,
+            cf_state.physics.circle.p.xy.at[:, 1].add(self._agent_radius),
         )
         state = _as_cfsstate(cf_state, smell)
         obs = _as_cfsobs(
@@ -150,3 +158,18 @@ def reset(  # type: ignore
             jnp.zeros((self.n_max_agents, self._n_food_sources)),
         )
         return state, TimeStep(encount=ts.encount, obs=obs)
+
+    def activate(  # type: ignore
+        self,
+        state: CFSState,
+        is_parent: jax.Array,
+    ) -> tuple[CFSState, jax.Array]:
+        cf_state, parent_id = super().activate(state, is_parent)
+        smell = _vmap_compute_smell(
+            self._n_food_sources,
+            self._smell_decay_factor,
+            cf_state.physics.static_circle,
+            cf_state.physics.circle.p.xy.at[:, 1].add(self._agent_radius),
+        )
+        new_state = _as_cfsstate(cf_state, smell)
+        return new_state, parent_id
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index ba405d83..81bd0db3 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -391,6 +391,8 @@ def __init__(
         max_place_attempts: int = 10,
         # Only for CircleForagingWithSmell, but placed here to keep config class simple
         smell_decay_factor: float = 0.01,
+        smell_diff_max: float = 1.0,
+        smell_diff_coef: float = 100.0,
     ) -> None:
         # Coordinate and range
         if env_shape == "square":
@@ -632,6 +634,8 @@ def food_collision_with_labels(
 
         # Smell
         self._smell_decay_factor = smell_decay_factor
+        self._smell_diff_max = smell_diff_max
+        self._smell_diff_coef = smell_diff_coef
 
     @staticmethod
     def _make_food_num_fn(
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index b945c5e9..28823396 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -67,6 +67,9 @@ class CfConfig:
     n_position_iter: int = 2
     n_physics_iter: int = 5
     max_place_attempts: int = 10
+    smell_decay_factor: float = 0.01
+    smell_diff_max: float = 1.0
+    smell_diff_coef: float = 100.0
 
     def apply_override(self, override: str) -> None:
         if 0 < len(override):

From 33a84d9eed97bf3e22f6b3100efd48ed0eb2dfd5 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 14 Feb 2024 14:19:08 +0900
Subject: [PATCH 254/337] Stress

---
 config/env/20240214-stress.toml | 38 +++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 config/env/20240214-stress.toml

diff --git a/config/env/20240214-stress.toml b/config/env/20240214-stress.toml
new file mode 100644
index 00000000..de13d205
--- /dev/null
+++ b/config/env/20240214-stress.toml
@@ -0,0 +1,38 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = [
+   "scheduled",
+   1024000,
+   ["logistic", 20, 0.01, 60],
+   ["logistic", 20, 0.01, 50],
+   ["logistic", 20, 0.01, 40],
+   ["logistic", 20, 0.01, 30],
+   ["logistic", 20, 0.01, 20],
+   ["logistic", 20, 0.01, 10],
+]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 7f0add3934de071fe08e880e812866de1540806d Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 14 Feb 2024 14:24:41 +0900
Subject: [PATCH 255/337] Fix food color for widget

---
 src/emevo/environments/moderngl_vis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index 6a38b0ec..facd527e 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -337,7 +337,7 @@ def __init__(
             self._circle_scaling = screen_height / y_range * 2
 
         if sc_color_opt is None:
-            self._sc_color = np.array([[254, 2, 162]])
+            self._sc_color = np.array([[254, 2, 162, 255]])
         else:
             self._sc_color = sc_color_opt
 

From 37fcd89a0161629c0fd0de7d3e7849d706a1882f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 14 Feb 2024 16:52:10 +0900
Subject: [PATCH 256/337] alpha_smell -> scale_smell

---
 experiments/cfs_as_evo.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/experiments/cfs_as_evo.py b/experiments/cfs_as_evo.py
index e1867263..2b79e50a 100644
--- a/experiments/cfs_as_evo.py
+++ b/experiments/cfs_as_evo.py
@@ -119,7 +119,7 @@ def exp_reward_serializer(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array
     w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action", "w_smell"])
     scale_dict = serialize_weight(
         scale,
-        ["scale_agent", "scale_food", "scale_wall", "scale_action", "alpha_smell"],
+        ["scale_agent", "scale_food", "scale_wall", "scale_action", "scale_smell"],
     )
     return w_dict | scale_dict
 

From ab0ba6b85ee21d63328ca04a22a9d116516ac92c Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 14 Feb 2024 17:25:28 +0900
Subject: [PATCH 257/337] seasons-noprepare

---
 config/env/20240214-seasons-noprepare.toml | 35 ++++++++++++++++
 config/env/20240214-seasons-tri-i1000.toml | 46 ++++++++++++++++++++++
 2 files changed, 81 insertions(+)
 create mode 100644 config/env/20240214-seasons-noprepare.toml
 create mode 100644 config/env/20240214-seasons-tri-i1000.toml

diff --git a/config/env/20240214-seasons-noprepare.toml b/config/env/20240214-seasons-noprepare.toml
new file mode 100644
index 00000000..5baf5dda
--- /dev/null
+++ b/config/env/20240214-seasons-noprepare.toml
@@ -0,0 +1,35 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = ["switching",
+   1000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+   ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+   ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file
diff --git a/config/env/20240214-seasons-tri-i1000.toml b/config/env/20240214-seasons-tri-i1000.toml
new file mode 100644
index 00000000..dc6090f9
--- /dev/null
+++ b/config/env/20240214-seasons-tri-i1000.toml
@@ -0,0 +1,46 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+# food_loc_fn = [
+#    "scheduled",
+#    1024000,
+#    ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+#    ["switching",
+#        1000,
+#        ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+#        ["gaussian", [240.0, 90.0], [48.0, 36.0]],
+#        ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+#    ],
+# ]
+food_loc_fn = [
+    "switching",
+    1000,
+    ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+    ["gaussian", [240.0, 90.0], [48.0, 36.0]],
+    ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 185b4adc4c2a17297695a9b08fb22a5021bc27f1 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 14 Feb 2024 17:35:12 +0900
Subject: [PATCH 258/337] Smell diff for rewards?

---
 experiments/cfs_as_evo.py     |   2 +-
 experiments/cfsdiff_as_evo.py | 632 ++++++++++++++++++++++++++++++++++
 2 files changed, 633 insertions(+), 1 deletion(-)
 create mode 100644 experiments/cfsdiff_as_evo.py

diff --git a/experiments/cfs_as_evo.py b/experiments/cfs_as_evo.py
index 2b79e50a..36e5dbd6 100644
--- a/experiments/cfs_as_evo.py
+++ b/experiments/cfs_as_evo.py
@@ -1,4 +1,4 @@
-"""[WIP] Asexual reward evolution with CircleForagingWithSmell"""
+""" Asexual reward evolution with CircleForagingWithSmell"""
 import dataclasses
 import enum
 import json
diff --git a/experiments/cfsdiff_as_evo.py b/experiments/cfsdiff_as_evo.py
new file mode 100644
index 00000000..8f75c189
--- /dev/null
+++ b/experiments/cfsdiff_as_evo.py
@@ -0,0 +1,632 @@
+"""Asexual reward evolution with CircleForagingWithSmell"""
+import dataclasses
+import enum
+import json
+from pathlib import Path
+from typing import Optional, cast
+
+import chex
+import equinox as eqx
+import jax
+import jax.numpy as jnp
+import numpy as np
+import optax
+import typer
+from serde import toml
+
+from emevo import Env
+from emevo import birth_and_death as bd
+from emevo import genetic_ops as gops
+from emevo import make
+from emevo.env import ObsProtocol as Obs
+from emevo.env import StateProtocol as State
+from emevo.eqx_utils import get_slice
+from emevo.eqx_utils import where as eqx_where
+from emevo.exp_utils import (
+    BDConfig,
+    CfConfig,
+    GopsConfig,
+    Log,
+    Logger,
+    LogMode,
+    SavedPhysicsState,
+    SavedProfile,
+)
+from emevo.reward_fn import (
+    ExponentialReward,
+    LinearReward,
+    RewardFn,
+    SigmoidReward,
+    SigmoidReward_01,
+    SinhReward,
+    mutate_reward_fn,
+    serialize_weight,
+)
+from emevo.rl.ppo_normal import (
+    NormalPPONet,
+    Rollout,
+    vmap_apply,
+    vmap_batch,
+    vmap_net,
+    vmap_update,
+    vmap_value,
+)
+from emevo.spaces import BoxSpace
+from emevo.visualizer import SaveVideoWrapper
+
+PROJECT_ROOT = Path(__file__).parent.parent
+
+
+class RewardKind(str, enum.Enum):
+    LINEAR = "linear"
+    EXPONENTIAL = "exponential"
+    SIGMOID = "sigmoid"
+    SIGMOID_01 = "sigmoid-01"
+    SINH = "sinh"
+
+
+@dataclasses.dataclass
+class RewardExtractor:
+    act_space: BoxSpace
+    act_coef: float
+    smell_coef: float
+    mask: dataclasses.InitVar[str] = "11111"
+    _mask_array: jax.Array = dataclasses.field(init=False)
+    _max_norm: jax.Array = dataclasses.field(init=False)
+
+    def __post_init__(self, mask: str) -> None:
+        mask_array = jnp.array([x == "1" for x in mask])
+        self._mask_array = jnp.expand_dims(mask_array, axis=0)
+        self._max_norm = jnp.sqrt(
+            jnp.sum(self.act_space.high**2, axis=-1, keepdims=True)
+        )
+
+    def normalize_action(self, action: jax.Array) -> jax.Array:
+        scaled = self.act_space.sigmoid_scale(action)
+        norm = jnp.sqrt(jnp.sum(scaled**2, axis=-1, keepdims=True))
+        return norm / self._max_norm
+
+    def extract_linear(
+        self,
+        collision: jax.Array,
+        action: jax.Array,
+        energy: jax.Array,
+        smell: jax.Array,
+    ) -> jax.Array:
+        del energy
+        act_input = self.act_coef * self.normalize_action(action)
+        smell_input = self.smell_coef * smell
+        return jnp.concatenate((collision, act_input, smell_input), axis=1) * self._mask_array
+
+    def extract_sigmoid(
+        self,
+        collision: jax.Array,
+        action: jax.Array,
+        energy: jax.Array,
+        smell: jax.Array,
+    ) -> tuple[jax.Array, jax.Array]:
+        act_input = self.act_coef * self.normalize_action(action)
+        smell_input = self.smell_coef * smell
+        reward_input = jnp.concatenate((collision, act_input, smell_input), axis=1)
+        return reward_input * self._mask_array, energy
+
+
+def linear_reward_serializer(w: jax.Array) -> dict[str, jax.Array]:
+    return serialize_weight(w, ["agent", "food", "wall", "action", "smell"])
+
+
+def exp_reward_serializer(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
+    w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action", "w_smell"])
+    scale_dict = serialize_weight(
+        scale,
+        ["scale_agent", "scale_food", "scale_wall", "scale_action", "scale_smell"],
+    )
+    return w_dict | scale_dict
+
+
+def sigmoid_reward_serializer(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
+    w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action", "w_smell"])
+    alpha_dict = serialize_weight(
+        alpha,
+        ["alpha_agent", "alpha_food", "alpha_wall", "alpha_action", "alpha_smell"],
+    )
+    return w_dict | alpha_dict
+
+
+def exec_rollout(
+    state: State,
+    initial_obs: Obs,
+    env: Env,
+    network: NormalPPONet,
+    reward_fn: RewardFn,
+    hazard_fn: bd.HazardFunction,
+    birth_fn: bd.BirthFunction,
+    prng_key: jax.Array,
+    n_rollout_steps: int,
+) -> tuple[State, Rollout, Log, SavedPhysicsState, Obs, jax.Array]:
+    def step_rollout(
+        carried: tuple[State, Obs],
+        key: jax.Array,
+    ) -> tuple[tuple[State, Obs], tuple[Rollout, Log, SavedPhysicsState]]:
+        act_key, hazard_key, birth_key = jax.random.split(key, 3)
+        state_t, obs_t = carried
+        obs_t_array = obs_t.as_array()
+        net_out = vmap_apply(network, obs_t_array)
+        actions = net_out.policy().sample(seed=act_key)
+        state_t1, timestep = env.step(
+            state_t,
+            env.act_space.sigmoid_scale(actions),  # type: ignore
+        )
+        obs_t1 = timestep.obs
+        energy = state_t.status.energy
+        smell = obs_t.smell_diff  # type: ignore
+        rewards = reward_fn(obs_t1.collision, actions, energy, smell).reshape(-1, 1)
+        rollout = Rollout(
+            observations=obs_t_array,
+            actions=actions,
+            rewards=rewards,
+            terminations=jnp.zeros_like(rewards),
+            values=net_out.value,
+            means=net_out.mean,
+            logstds=net_out.logstd,
+        )
+        # Birth and death
+        death_prob = hazard_fn(state_t1.status.age, state_t1.status.energy)
+        dead = jax.random.bernoulli(hazard_key, p=death_prob)
+        state_t1d = env.deactivate(state_t1, dead)
+        birth_prob = birth_fn(state_t1d.status.age, state_t1d.status.energy)
+        possible_parents = jnp.logical_and(
+            jnp.logical_and(
+                jnp.logical_not(dead),
+                state.unique_id.is_active(),  # type: ignore
+            ),
+            jax.random.bernoulli(birth_key, p=birth_prob),
+        )
+        state_t1db, parents = env.activate(state_t1d, possible_parents)
+        log = Log(
+            dead=jnp.where(dead, state_t.unique_id.unique_id, -1),  # type: ignore
+            got_food=obs_t1.collision[:, 1],
+            parents=parents,
+            rewards=rewards.ravel(),
+            age=state_t1db.status.age,
+            energy=state_t1db.status.energy,
+            unique_id=state_t1db.unique_id.unique_id,
+        )
+        phys = state_t.physics  # type: ignore
+        phys_state = SavedPhysicsState(
+            circle_axy=phys.circle.p.into_axy(),
+            static_circle_axy=phys.static_circle.p.into_axy(),
+            circle_is_active=phys.circle.is_active,
+            static_circle_is_active=phys.static_circle.is_active,
+            static_circle_label=phys.static_circle.label,
+        )
+        return (state_t1db, obs_t1), (rollout, log, phys_state)
+
+    (state, obs), (rollout, log, phys_state) = jax.lax.scan(
+        step_rollout,
+        (state, initial_obs),
+        jax.random.split(prng_key, n_rollout_steps),
+    )
+    next_value = vmap_value(network, obs.as_array())
+    return state, rollout, log, phys_state, obs, next_value
+
+
+@eqx.filter_jit
+def epoch(
+    state: State,
+    initial_obs: Obs,
+    env: Env,
+    network: NormalPPONet,
+    reward_fn: RewardFn,
+    hazard_fn: bd.HazardFunction,
+    birth_fn: bd.BirthFunction,
+    prng_key: jax.Array,
+    n_rollout_steps: int,
+    gamma: float,
+    gae_lambda: float,
+    adam_update: optax.TransformUpdateFn,
+    opt_state: optax.OptState,
+    minibatch_size: int,
+    n_optim_epochs: int,
+) -> tuple[State, Obs, Log, SavedPhysicsState, optax.OptState, NormalPPONet]:
+    keys = jax.random.split(prng_key, env.n_max_agents + 1)
+    env_state, rollout, log, phys_state, obs, next_value = exec_rollout(
+        state,
+        initial_obs,
+        env,
+        network,
+        reward_fn,
+        hazard_fn,
+        birth_fn,
+        keys[0],
+        n_rollout_steps,
+    )
+    batch = vmap_batch(rollout, next_value, gamma, gae_lambda)
+    opt_state, pponet = vmap_update(
+        batch,
+        network,
+        adam_update,
+        opt_state,
+        keys[1:],
+        minibatch_size,
+        n_optim_epochs,
+        0.2,
+        0.0,
+    )
+    return env_state, obs, log, phys_state, opt_state, pponet
+
+
+def run_evolution(
+    *,
+    key: jax.Array,
+    env: Env,
+    n_initial_agents: int,
+    adam: optax.GradientTransformation,
+    gamma: float,
+    gae_lambda: float,
+    n_optim_epochs: int,
+    minibatch_size: int,
+    n_rollout_steps: int,
+    n_total_steps: int,
+    reward_fn: RewardFn,
+    hazard_fn: bd.HazardFunction,
+    birth_fn: bd.BirthFunction,
+    mutation: gops.Mutation,
+    xmax: float,
+    ymax: float,
+    logger: Logger,
+    debug_vis: bool,
+) -> None:
+    key, net_key, reset_key = jax.random.split(key, 3)
+    obs_space = env.obs_space.flatten()
+    input_size = np.prod(obs_space.shape)
+    act_size = np.prod(env.act_space.shape)
+
+    def initialize_net(key: chex.PRNGKey) -> NormalPPONet:
+        return vmap_net(
+            input_size,
+            64,
+            act_size,
+            jax.random.split(key, env.n_max_agents),
+        )
+
+    pponet = initialize_net(net_key)
+    adam_init, adam_update = adam
+
+    @eqx.filter_jit
+    def initialize_opt_state(net: eqx.Module) -> optax.OptState:
+        return jax.vmap(adam_init)(eqx.filter(net, eqx.is_array))
+
+    @eqx.filter_jit
+    def replace_net(
+        key: chex.PRNGKey,
+        flag: jax.Array,
+        pponet: NormalPPONet,
+        opt_state: optax.OptState,
+    ) -> tuple[NormalPPONet, optax.OptState]:
+        initialized = initialize_net(key)
+        pponet = eqx_where(flag, initialized, pponet)
+        opt_state = jax.tree_map(
+            lambda a, b: jnp.where(
+                jnp.expand_dims(flag, tuple(range(1, a.ndim))),
+                b,
+                a,
+            ),
+            opt_state,
+            initialize_opt_state(pponet),
+        )
+        return pponet, opt_state
+
+    opt_state = initialize_opt_state(pponet)
+    env_state, timestep = env.reset(reset_key)
+    obs = timestep.obs
+
+    if debug_vis:
+        visualizer = env.visualizer(env_state, figsize=(xmax * 2, ymax * 2))
+    else:
+        visualizer = None
+
+    for i in range(n_initial_agents):
+        logger.reward_fn_dict[i + 1] = get_slice(reward_fn, i)
+        logger.profile_dict[i + 1] = SavedProfile(0, 0, i + 1)
+
+    for i, key in enumerate(jax.random.split(key, n_total_steps // n_rollout_steps)):
+        epoch_key, init_key = jax.random.split(key)
+        env_state, obs, log, phys_state, opt_state, pponet = epoch(
+            env_state,
+            obs,
+            env,
+            pponet,
+            reward_fn,
+            hazard_fn,
+            birth_fn,
+            epoch_key,
+            n_rollout_steps,
+            gamma,
+            gae_lambda,
+            adam_update,
+            opt_state,
+            minibatch_size,
+            n_optim_epochs,
+        )
+
+        if visualizer is not None:
+            visualizer.render(env_state.physics)  # type: ignore
+            visualizer.show()
+        # Extinct?
+        n_active = jnp.sum(env_state.unique_id.is_active())  # type: ignore
+        if n_active == 0:
+            print(f"Extinct after {i + 1} epochs")
+            break
+
+        # Save network
+        log_with_step = log.with_step(i * n_rollout_steps)
+        log_death = log_with_step.filter_death()
+        logger.save_agents(pponet, log_death.dead, log_death.slots)
+        log_birth = log_with_step.filter_birth()
+        # Initialize network and adam state for new agents
+        is_new = jnp.zeros(env.n_max_agents, dtype=bool).at[log_birth.slots].set(True)
+        if jnp.any(is_new):
+            pponet, opt_state = replace_net(init_key, is_new, pponet, opt_state)
+
+        # Mutation
+        reward_fn = mutate_reward_fn(
+            key,
+            logger.reward_fn_dict,
+            reward_fn,
+            mutation,
+            log_birth.parents,
+            log_birth.unique_id,
+            log_birth.slots,
+        )
+        # Update profile
+        for step, uid, parent in zip(
+            log_birth.step,
+            log_birth.unique_id,
+            log_birth.parents,
+        ):
+            ui = uid.item()
+            logger.profile_dict[ui] = SavedProfile(step.item(), parent.item(), ui)
+
+        # Push log and physics state
+        logger.push_log(log_with_step.filter_active())
+        logger.push_physstate(phys_state)
+
+    # Save logs before exiting
+    logger.finalize()
+    is_active = env_state.unique_id.is_active()
+    logger.save_agents(
+        pponet,
+        env_state.unique_id.unique_id[is_active],
+        jnp.arange(len(is_active))[is_active],
+    )
+
+
+app = typer.Typer(pretty_exceptions_show_locals=False)
+
+
+@app.command()
+def evolve(
+    seed: int = 1,
+    n_agents: int = 20,
+    init_energy: float = 20.0,
+    action_cost: float = 0.0001,
+    mutation_prob: float = 0.2,
+    adam_lr: float = 3e-4,
+    adam_eps: float = 1e-7,
+    gamma: float = 0.999,
+    gae_lambda: float = 0.95,
+    n_optim_epochs: int = 10,
+    minibatch_size: int = 256,
+    n_rollout_steps: int = 1024,
+    n_total_steps: int = 1024 * 10000,
+    act_reward_coef: float = 0.001,
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
+    bdconfig_path: Path = PROJECT_ROOT / "config/bd/20230530-a035-e020.toml",
+    gopsconfig_path: Path = PROJECT_ROOT / "config/gops/20240111-mutation-0401.toml",
+    env_override: str = "",
+    birth_override: str = "",
+    hazard_override: str = "",
+    reward_mask: str = "11111",
+    reward_fn: RewardKind = RewardKind.LINEAR,
+    logdir: Path = Path("./log"),
+    log_mode: LogMode = LogMode.FULL,
+    log_interval: int = 1000,
+    savestate_interval: int = 1000,
+    debug_vis: bool = False,
+) -> None:
+    # Load config
+    with cfconfig_path.open("r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+    with bdconfig_path.open("r") as f:
+        bdconfig = toml.from_toml(BDConfig, f.read())
+    with gopsconfig_path.open("r") as f:
+        gopsconfig = toml.from_toml(GopsConfig, f.read())
+
+    # Apply overrides
+    cfconfig.apply_override(env_override)
+    bdconfig.apply_birth_override(birth_override)
+    bdconfig.apply_hazard_override(hazard_override)
+
+    # Load models
+    birth_fn, hazard_fn = bdconfig.load_models()
+    mutation = gopsconfig.load_model()
+    # Override config
+    cfconfig.n_initial_agents = n_agents
+    cfconfig.init_energy = init_energy
+    cfconfig.force_energy_consumption = action_cost
+    gopsconfig.params["mutation_prob"] = mutation_prob
+    # Make env
+    env = make("CircleForaging-v1", **dataclasses.asdict(cfconfig))
+    key, reward_key = jax.random.split(jax.random.PRNGKey(seed))
+    reward_extracor = RewardExtractor(
+        act_space=env.act_space,  # type: ignore
+        act_coef=act_reward_coef,
+        smell_coef=0.01,
+        mask=reward_mask,
+    )
+    common_rewardfn_args = {
+        "key": reward_key,
+        "n_agents": cfconfig.n_max_agents,
+        "n_weights": 5,
+        "std": gopsconfig.init_std,
+        "mean": gopsconfig.init_mean,
+    }
+    if reward_fn == RewardKind.LINEAR:
+        reward_fn_instance = LinearReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_linear,
+            serializer=linear_reward_serializer,
+        )
+    elif reward_fn == RewardKind.EXPONENTIAL:
+        reward_fn_instance = ExponentialReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_linear,
+            serializer=exp_reward_serializer,
+        )
+    elif reward_fn == RewardKind.SIGMOID:
+        reward_fn_instance = SigmoidReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=sigmoid_reward_serializer,
+        )
+    elif reward_fn == RewardKind.SIGMOID_01:
+        reward_fn_instance = SigmoidReward_01(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=sigmoid_reward_serializer,
+        )
+    elif reward_fn == RewardKind.SINH:
+        reward_fn_instance = SinhReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_linear,
+            serializer=linear_reward_serializer,
+        )
+    else:
+        raise ValueError(f"Invalid reward_fn {reward_fn}")
+
+    logger = Logger(
+        logdir=logdir,
+        mode=log_mode,
+        log_interval=log_interval,
+        savestate_interval=savestate_interval,
+    )
+    run_evolution(
+        key=key,
+        env=env,
+        n_initial_agents=n_agents,
+        adam=optax.adam(adam_lr, eps=adam_eps),
+        gamma=gamma,
+        gae_lambda=gae_lambda,
+        n_optim_epochs=n_optim_epochs,
+        minibatch_size=minibatch_size,
+        n_rollout_steps=n_rollout_steps,
+        n_total_steps=n_total_steps,
+        reward_fn=reward_fn_instance,
+        hazard_fn=hazard_fn,
+        birth_fn=birth_fn,
+        mutation=cast(gops.Mutation, mutation),
+        xmax=cfconfig.xlim[1],
+        ymax=cfconfig.ylim[1],
+        logger=logger,
+        debug_vis=debug_vis,
+    )
+
+
+@app.command()
+def replay(
+    physstate_path: Path,
+    backend: str = "pyglet",  # Use "headless" for headless rendering
+    videopath: Optional[Path] = None,
+    start: int = 0,
+    end: Optional[int] = None,
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
+    env_override: str = "",
+) -> None:
+    with cfconfig_path.open("r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+    # For speedup
+    cfconfig.n_initial_agents = 1
+    cfconfig.apply_override(env_override)
+    phys_state = SavedPhysicsState.load(physstate_path)
+    env = make("CircleForaging-v1", **dataclasses.asdict(cfconfig))
+    env_state, _ = env.reset(jax.random.PRNGKey(0))
+    end_index = end if end is not None else phys_state.circle_axy.shape[0]
+    visualizer = env.visualizer(
+        env_state,
+        figsize=(cfconfig.xlim[1] * 2, cfconfig.ylim[1] * 2),
+        backend=backend,
+    )
+    if videopath is not None:
+        visualizer = SaveVideoWrapper(visualizer, videopath, fps=60)
+    for i in range(start, end_index):
+        phys = phys_state.set_by_index(i, env_state.physics)
+        env_state = dataclasses.replace(env_state, physics=phys)
+        visualizer.render(env_state.physics)
+        visualizer.show()
+    visualizer.close()
+
+
+@app.command()
+def widget(
+    physstate_path: Path,
+    start: int = 0,
+    end: Optional[int] = None,
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
+    log_offset: int = 0,
+    log_path: Optional[Path] = None,
+    self_terminate: bool = False,
+    profile_and_rewards_path: Optional[Path] = None,
+    cm_fixed_minmax: str = "",
+    env_override: str = "",
+) -> None:
+    from emevo.analysis.qt_widget import CFEnvReplayWidget, start_widget
+
+    with cfconfig_path.open("r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+    # For speedup
+    cfconfig.n_initial_agents = 1
+    cfconfig.apply_override(env_override)
+    phys_state = SavedPhysicsState.load(physstate_path)
+    env = make("CircleForaging-v1", **dataclasses.asdict(cfconfig))
+    end = phys_state.circle_axy.shape[0] if end is None else end
+    if log_path is None:
+        log_ds = None
+        step_offset = 0
+    else:
+        import pyarrow.dataset as ds
+
+        log_ds = ds.dataset(log_path)
+        first_step = log_ds.scanner(columns=["step"]).head(1)["step"][0].as_py()
+        step_offset = first_step + log_offset
+
+    if profile_and_rewards_path is None:
+        profile_and_rewards = None
+    else:
+        import pyarrow.parquet as pq
+
+        profile_and_rewards = pq.read_table(profile_and_rewards_path)
+
+    if len(cm_fixed_minmax) > 0:
+        cm_fixed_minmax_dict = json.loads(cm_fixed_minmax)
+    else:
+        cm_fixed_minmax_dict = {}
+
+    start_widget(
+        CFEnvReplayWidget,
+        xlim=int(cfconfig.xlim[1]),
+        ylim=int(cfconfig.ylim[1]),
+        env=env,
+        saved_physics=phys_state,
+        start=start,
+        end=end,
+        log_ds=log_ds,
+        step_offset=step_offset,
+        self_terminate=self_terminate,
+        profile_and_rewards=profile_and_rewards,
+        cm_fixed_minmax=cm_fixed_minmax_dict,
+    )
+
+
+if __name__ == "__main__":
+    app()

From 36b33625ce7a5417545b8947905ee4a8dcd7a353 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Thu, 15 Feb 2024 12:21:28 +0900
Subject: [PATCH 259/337] Make stress test a bit more harsh

---
 config/env/20240214-stress.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/config/env/20240214-stress.toml b/config/env/20240214-stress.toml
index de13d205..9b16717d 100644
--- a/config/env/20240214-stress.toml
+++ b/config/env/20240214-stress.toml
@@ -4,7 +4,6 @@ n_max_foods = 60
 food_num_fn = [
    "scheduled",
    1024000,
-   ["logistic", 20, 0.01, 60],
    ["logistic", 20, 0.01, 50],
    ["logistic", 20, 0.01, 40],
    ["logistic", 20, 0.01, 30],

From c94470cc41e8be4863d57d76ccd57db7f4d217f8 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 16 Feb 2024 14:21:51 +0900
Subject: [PATCH 260/337] constant

---
 config/env/20240216-constant.toml | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 config/env/20240216-constant.toml

diff --git a/config/env/20240216-constant.toml b/config/env/20240216-constant.toml
new file mode 100644
index 00000000..db6dc1ec
--- /dev/null
+++ b/config/env/20240216-constant.toml
@@ -0,0 +1,29 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["constant", 50]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From d0d9f44045fef001d0067106c908d894ceb6dc88 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 16 Feb 2024 14:33:10 +0900
Subject: [PATCH 261/337] [widget] Shorten bar name

---
 src/emevo/analysis/qt_widget.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index 4a8aadf6..31177a15 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -248,6 +248,9 @@ def _make_barset(self, name: str, value: float | list[float]) -> QBarSet:
             warnings.warn(f"Invalid value for barset: {value}", stacklevel=1)
         self.barsets[name] = barset
         self.series.append(barset)
+        if "_" in name:  # Shorten name
+            us_ind = name.index("_")
+            barset.setLabel(f"{name[0]}_{name[us_ind + 1: us_ind + 3]}")
         return barset
 
     def _update_yrange(self, values: Iterable[float | list[float]]) -> None:

From 687157fc4b1eb21d2d2900c57d952c4d2f009011 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Fri, 16 Feb 2024 14:38:50 +0900
Subject: [PATCH 262/337] Tweak on tri1000

---
 config/env/20240214-seasons-tri-i1000.toml | 25 ++++++++--------------
 1 file changed, 9 insertions(+), 16 deletions(-)

diff --git a/config/env/20240214-seasons-tri-i1000.toml b/config/env/20240214-seasons-tri-i1000.toml
index dc6090f9..ad90c7b9 100644
--- a/config/env/20240214-seasons-tri-i1000.toml
+++ b/config/env/20240214-seasons-tri-i1000.toml
@@ -2,23 +2,16 @@ n_initial_agents = 50
 n_max_agents = 150
 n_max_foods = 60
 food_num_fn = ["logistic", 20, 0.01, 60]
-# food_loc_fn = [
-#    "scheduled",
-#    1024000,
-#    ["gaussian", [360.0, 270.0], [48.0, 36.0]],
-#    ["switching",
-#        1000,
-#        ["gaussian", [360.0, 270.0], [48.0, 36.0]],
-#        ["gaussian", [240.0, 90.0], [48.0, 36.0]],
-#        ["gaussian", [120.0, 270.0], [48.0, 36.0]],
-#    ],
-# ]
 food_loc_fn = [
-    "switching",
-    1000,
-    ["gaussian", [360.0, 270.0], [48.0, 36.0]],
-    ["gaussian", [240.0, 90.0], [48.0, 36.0]],
-    ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+   "scheduled",
+   1024000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["switching",
+       1000,
+       ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 90.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+   ],
 ]
 agent_loc_fn = "uniform"
 xlim = [0.0, 480.0]

From 20ccffebc1aad2c5eeac959fc968e00408711e9b Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 16 Feb 2024 14:39:33 +0900
Subject: [PATCH 263/337] One more word for barset

---
 src/emevo/analysis/qt_widget.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index 31177a15..103be322 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -250,7 +250,7 @@ def _make_barset(self, name: str, value: float | list[float]) -> QBarSet:
         self.series.append(barset)
         if "_" in name:  # Shorten name
             us_ind = name.index("_")
-            barset.setLabel(f"{name[0]}_{name[us_ind + 1: us_ind + 3]}")
+            barset.setLabel(f"{name[0]}_{name[us_ind + 1: us_ind + 4]}")
         return barset
 
     def _update_yrange(self, values: Iterable[float | list[float]]) -> None:

From a2feff4c9a14eafa65c02ebfae59cae07c2b22c4 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 16 Feb 2024 14:53:08 +0900
Subject: [PATCH 264/337] 4season

---
 config/env/20240216-4seasons.toml | 40 +++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 config/env/20240216-4seasons.toml

diff --git a/config/env/20240216-4seasons.toml b/config/env/20240216-4seasons.toml
new file mode 100644
index 00000000..375f2800
--- /dev/null
+++ b/config/env/20240216-4seasons.toml
@@ -0,0 +1,40 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["switching",
+       1000,
+       ["gaussian", [360.0, 180.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 180.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 90.0], [48.0, 36.0]],
+   ],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 7409436c6f7770aa88c33bba946bc447fd9549dd Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 16 Feb 2024 15:23:04 +0900
Subject: [PATCH 265/337] poison

---
 config/env/20240216-poison.toml | 38 +++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 config/env/20240216-poison.toml

diff --git a/config/env/20240216-poison.toml b/config/env/20240216-poison.toml
new file mode 100644
index 00000000..045173b8
--- /dev/null
+++ b/config/env/20240216-poison.toml
@@ -0,0 +1,38 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+n_food_sources = 2
+food_num_fn = [
+    ["logistic", 20, 0.01, 40],
+    ["logistic", 10, 0.01, 20],
+]
+food_loc_fn = [
+   ["gaussian", [300.0, 180.0], [48.0, 36.0]],
+   ["gaussian", [180.0, 180.0], [48.0, 36.0]],
+]
+food_color = [[254, 2, 162, 255], [2, 254, 162, 255]]
+food_energy_coef = [1.0, -0.1]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 08b0a345f1dc34093631288d64d124a571dbe00a Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 17 Feb 2024 16:32:10 +0900
Subject: [PATCH 266/337] Duplicate cfsdiff

---
 experiments/cfsdiff_as_evo.py | 632 ----------------------------------
 1 file changed, 632 deletions(-)
 delete mode 100644 experiments/cfsdiff_as_evo.py

diff --git a/experiments/cfsdiff_as_evo.py b/experiments/cfsdiff_as_evo.py
deleted file mode 100644
index 8f75c189..00000000
--- a/experiments/cfsdiff_as_evo.py
+++ /dev/null
@@ -1,632 +0,0 @@
-"""Asexual reward evolution with CircleForagingWithSmell"""
-import dataclasses
-import enum
-import json
-from pathlib import Path
-from typing import Optional, cast
-
-import chex
-import equinox as eqx
-import jax
-import jax.numpy as jnp
-import numpy as np
-import optax
-import typer
-from serde import toml
-
-from emevo import Env
-from emevo import birth_and_death as bd
-from emevo import genetic_ops as gops
-from emevo import make
-from emevo.env import ObsProtocol as Obs
-from emevo.env import StateProtocol as State
-from emevo.eqx_utils import get_slice
-from emevo.eqx_utils import where as eqx_where
-from emevo.exp_utils import (
-    BDConfig,
-    CfConfig,
-    GopsConfig,
-    Log,
-    Logger,
-    LogMode,
-    SavedPhysicsState,
-    SavedProfile,
-)
-from emevo.reward_fn import (
-    ExponentialReward,
-    LinearReward,
-    RewardFn,
-    SigmoidReward,
-    SigmoidReward_01,
-    SinhReward,
-    mutate_reward_fn,
-    serialize_weight,
-)
-from emevo.rl.ppo_normal import (
-    NormalPPONet,
-    Rollout,
-    vmap_apply,
-    vmap_batch,
-    vmap_net,
-    vmap_update,
-    vmap_value,
-)
-from emevo.spaces import BoxSpace
-from emevo.visualizer import SaveVideoWrapper
-
-PROJECT_ROOT = Path(__file__).parent.parent
-
-
-class RewardKind(str, enum.Enum):
-    LINEAR = "linear"
-    EXPONENTIAL = "exponential"
-    SIGMOID = "sigmoid"
-    SIGMOID_01 = "sigmoid-01"
-    SINH = "sinh"
-
-
-@dataclasses.dataclass
-class RewardExtractor:
-    act_space: BoxSpace
-    act_coef: float
-    smell_coef: float
-    mask: dataclasses.InitVar[str] = "11111"
-    _mask_array: jax.Array = dataclasses.field(init=False)
-    _max_norm: jax.Array = dataclasses.field(init=False)
-
-    def __post_init__(self, mask: str) -> None:
-        mask_array = jnp.array([x == "1" for x in mask])
-        self._mask_array = jnp.expand_dims(mask_array, axis=0)
-        self._max_norm = jnp.sqrt(
-            jnp.sum(self.act_space.high**2, axis=-1, keepdims=True)
-        )
-
-    def normalize_action(self, action: jax.Array) -> jax.Array:
-        scaled = self.act_space.sigmoid_scale(action)
-        norm = jnp.sqrt(jnp.sum(scaled**2, axis=-1, keepdims=True))
-        return norm / self._max_norm
-
-    def extract_linear(
-        self,
-        collision: jax.Array,
-        action: jax.Array,
-        energy: jax.Array,
-        smell: jax.Array,
-    ) -> jax.Array:
-        del energy
-        act_input = self.act_coef * self.normalize_action(action)
-        smell_input = self.smell_coef * smell
-        return jnp.concatenate((collision, act_input, smell_input), axis=1) * self._mask_array
-
-    def extract_sigmoid(
-        self,
-        collision: jax.Array,
-        action: jax.Array,
-        energy: jax.Array,
-        smell: jax.Array,
-    ) -> tuple[jax.Array, jax.Array]:
-        act_input = self.act_coef * self.normalize_action(action)
-        smell_input = self.smell_coef * smell
-        reward_input = jnp.concatenate((collision, act_input, smell_input), axis=1)
-        return reward_input * self._mask_array, energy
-
-
-def linear_reward_serializer(w: jax.Array) -> dict[str, jax.Array]:
-    return serialize_weight(w, ["agent", "food", "wall", "action", "smell"])
-
-
-def exp_reward_serializer(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
-    w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action", "w_smell"])
-    scale_dict = serialize_weight(
-        scale,
-        ["scale_agent", "scale_food", "scale_wall", "scale_action", "scale_smell"],
-    )
-    return w_dict | scale_dict
-
-
-def sigmoid_reward_serializer(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
-    w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action", "w_smell"])
-    alpha_dict = serialize_weight(
-        alpha,
-        ["alpha_agent", "alpha_food", "alpha_wall", "alpha_action", "alpha_smell"],
-    )
-    return w_dict | alpha_dict
-
-
-def exec_rollout(
-    state: State,
-    initial_obs: Obs,
-    env: Env,
-    network: NormalPPONet,
-    reward_fn: RewardFn,
-    hazard_fn: bd.HazardFunction,
-    birth_fn: bd.BirthFunction,
-    prng_key: jax.Array,
-    n_rollout_steps: int,
-) -> tuple[State, Rollout, Log, SavedPhysicsState, Obs, jax.Array]:
-    def step_rollout(
-        carried: tuple[State, Obs],
-        key: jax.Array,
-    ) -> tuple[tuple[State, Obs], tuple[Rollout, Log, SavedPhysicsState]]:
-        act_key, hazard_key, birth_key = jax.random.split(key, 3)
-        state_t, obs_t = carried
-        obs_t_array = obs_t.as_array()
-        net_out = vmap_apply(network, obs_t_array)
-        actions = net_out.policy().sample(seed=act_key)
-        state_t1, timestep = env.step(
-            state_t,
-            env.act_space.sigmoid_scale(actions),  # type: ignore
-        )
-        obs_t1 = timestep.obs
-        energy = state_t.status.energy
-        smell = obs_t.smell_diff  # type: ignore
-        rewards = reward_fn(obs_t1.collision, actions, energy, smell).reshape(-1, 1)
-        rollout = Rollout(
-            observations=obs_t_array,
-            actions=actions,
-            rewards=rewards,
-            terminations=jnp.zeros_like(rewards),
-            values=net_out.value,
-            means=net_out.mean,
-            logstds=net_out.logstd,
-        )
-        # Birth and death
-        death_prob = hazard_fn(state_t1.status.age, state_t1.status.energy)
-        dead = jax.random.bernoulli(hazard_key, p=death_prob)
-        state_t1d = env.deactivate(state_t1, dead)
-        birth_prob = birth_fn(state_t1d.status.age, state_t1d.status.energy)
-        possible_parents = jnp.logical_and(
-            jnp.logical_and(
-                jnp.logical_not(dead),
-                state.unique_id.is_active(),  # type: ignore
-            ),
-            jax.random.bernoulli(birth_key, p=birth_prob),
-        )
-        state_t1db, parents = env.activate(state_t1d, possible_parents)
-        log = Log(
-            dead=jnp.where(dead, state_t.unique_id.unique_id, -1),  # type: ignore
-            got_food=obs_t1.collision[:, 1],
-            parents=parents,
-            rewards=rewards.ravel(),
-            age=state_t1db.status.age,
-            energy=state_t1db.status.energy,
-            unique_id=state_t1db.unique_id.unique_id,
-        )
-        phys = state_t.physics  # type: ignore
-        phys_state = SavedPhysicsState(
-            circle_axy=phys.circle.p.into_axy(),
-            static_circle_axy=phys.static_circle.p.into_axy(),
-            circle_is_active=phys.circle.is_active,
-            static_circle_is_active=phys.static_circle.is_active,
-            static_circle_label=phys.static_circle.label,
-        )
-        return (state_t1db, obs_t1), (rollout, log, phys_state)
-
-    (state, obs), (rollout, log, phys_state) = jax.lax.scan(
-        step_rollout,
-        (state, initial_obs),
-        jax.random.split(prng_key, n_rollout_steps),
-    )
-    next_value = vmap_value(network, obs.as_array())
-    return state, rollout, log, phys_state, obs, next_value
-
-
-@eqx.filter_jit
-def epoch(
-    state: State,
-    initial_obs: Obs,
-    env: Env,
-    network: NormalPPONet,
-    reward_fn: RewardFn,
-    hazard_fn: bd.HazardFunction,
-    birth_fn: bd.BirthFunction,
-    prng_key: jax.Array,
-    n_rollout_steps: int,
-    gamma: float,
-    gae_lambda: float,
-    adam_update: optax.TransformUpdateFn,
-    opt_state: optax.OptState,
-    minibatch_size: int,
-    n_optim_epochs: int,
-) -> tuple[State, Obs, Log, SavedPhysicsState, optax.OptState, NormalPPONet]:
-    keys = jax.random.split(prng_key, env.n_max_agents + 1)
-    env_state, rollout, log, phys_state, obs, next_value = exec_rollout(
-        state,
-        initial_obs,
-        env,
-        network,
-        reward_fn,
-        hazard_fn,
-        birth_fn,
-        keys[0],
-        n_rollout_steps,
-    )
-    batch = vmap_batch(rollout, next_value, gamma, gae_lambda)
-    opt_state, pponet = vmap_update(
-        batch,
-        network,
-        adam_update,
-        opt_state,
-        keys[1:],
-        minibatch_size,
-        n_optim_epochs,
-        0.2,
-        0.0,
-    )
-    return env_state, obs, log, phys_state, opt_state, pponet
-
-
-def run_evolution(
-    *,
-    key: jax.Array,
-    env: Env,
-    n_initial_agents: int,
-    adam: optax.GradientTransformation,
-    gamma: float,
-    gae_lambda: float,
-    n_optim_epochs: int,
-    minibatch_size: int,
-    n_rollout_steps: int,
-    n_total_steps: int,
-    reward_fn: RewardFn,
-    hazard_fn: bd.HazardFunction,
-    birth_fn: bd.BirthFunction,
-    mutation: gops.Mutation,
-    xmax: float,
-    ymax: float,
-    logger: Logger,
-    debug_vis: bool,
-) -> None:
-    key, net_key, reset_key = jax.random.split(key, 3)
-    obs_space = env.obs_space.flatten()
-    input_size = np.prod(obs_space.shape)
-    act_size = np.prod(env.act_space.shape)
-
-    def initialize_net(key: chex.PRNGKey) -> NormalPPONet:
-        return vmap_net(
-            input_size,
-            64,
-            act_size,
-            jax.random.split(key, env.n_max_agents),
-        )
-
-    pponet = initialize_net(net_key)
-    adam_init, adam_update = adam
-
-    @eqx.filter_jit
-    def initialize_opt_state(net: eqx.Module) -> optax.OptState:
-        return jax.vmap(adam_init)(eqx.filter(net, eqx.is_array))
-
-    @eqx.filter_jit
-    def replace_net(
-        key: chex.PRNGKey,
-        flag: jax.Array,
-        pponet: NormalPPONet,
-        opt_state: optax.OptState,
-    ) -> tuple[NormalPPONet, optax.OptState]:
-        initialized = initialize_net(key)
-        pponet = eqx_where(flag, initialized, pponet)
-        opt_state = jax.tree_map(
-            lambda a, b: jnp.where(
-                jnp.expand_dims(flag, tuple(range(1, a.ndim))),
-                b,
-                a,
-            ),
-            opt_state,
-            initialize_opt_state(pponet),
-        )
-        return pponet, opt_state
-
-    opt_state = initialize_opt_state(pponet)
-    env_state, timestep = env.reset(reset_key)
-    obs = timestep.obs
-
-    if debug_vis:
-        visualizer = env.visualizer(env_state, figsize=(xmax * 2, ymax * 2))
-    else:
-        visualizer = None
-
-    for i in range(n_initial_agents):
-        logger.reward_fn_dict[i + 1] = get_slice(reward_fn, i)
-        logger.profile_dict[i + 1] = SavedProfile(0, 0, i + 1)
-
-    for i, key in enumerate(jax.random.split(key, n_total_steps // n_rollout_steps)):
-        epoch_key, init_key = jax.random.split(key)
-        env_state, obs, log, phys_state, opt_state, pponet = epoch(
-            env_state,
-            obs,
-            env,
-            pponet,
-            reward_fn,
-            hazard_fn,
-            birth_fn,
-            epoch_key,
-            n_rollout_steps,
-            gamma,
-            gae_lambda,
-            adam_update,
-            opt_state,
-            minibatch_size,
-            n_optim_epochs,
-        )
-
-        if visualizer is not None:
-            visualizer.render(env_state.physics)  # type: ignore
-            visualizer.show()
-        # Extinct?
-        n_active = jnp.sum(env_state.unique_id.is_active())  # type: ignore
-        if n_active == 0:
-            print(f"Extinct after {i + 1} epochs")
-            break
-
-        # Save network
-        log_with_step = log.with_step(i * n_rollout_steps)
-        log_death = log_with_step.filter_death()
-        logger.save_agents(pponet, log_death.dead, log_death.slots)
-        log_birth = log_with_step.filter_birth()
-        # Initialize network and adam state for new agents
-        is_new = jnp.zeros(env.n_max_agents, dtype=bool).at[log_birth.slots].set(True)
-        if jnp.any(is_new):
-            pponet, opt_state = replace_net(init_key, is_new, pponet, opt_state)
-
-        # Mutation
-        reward_fn = mutate_reward_fn(
-            key,
-            logger.reward_fn_dict,
-            reward_fn,
-            mutation,
-            log_birth.parents,
-            log_birth.unique_id,
-            log_birth.slots,
-        )
-        # Update profile
-        for step, uid, parent in zip(
-            log_birth.step,
-            log_birth.unique_id,
-            log_birth.parents,
-        ):
-            ui = uid.item()
-            logger.profile_dict[ui] = SavedProfile(step.item(), parent.item(), ui)
-
-        # Push log and physics state
-        logger.push_log(log_with_step.filter_active())
-        logger.push_physstate(phys_state)
-
-    # Save logs before exiting
-    logger.finalize()
-    is_active = env_state.unique_id.is_active()
-    logger.save_agents(
-        pponet,
-        env_state.unique_id.unique_id[is_active],
-        jnp.arange(len(is_active))[is_active],
-    )
-
-
-app = typer.Typer(pretty_exceptions_show_locals=False)
-
-
-@app.command()
-def evolve(
-    seed: int = 1,
-    n_agents: int = 20,
-    init_energy: float = 20.0,
-    action_cost: float = 0.0001,
-    mutation_prob: float = 0.2,
-    adam_lr: float = 3e-4,
-    adam_eps: float = 1e-7,
-    gamma: float = 0.999,
-    gae_lambda: float = 0.95,
-    n_optim_epochs: int = 10,
-    minibatch_size: int = 256,
-    n_rollout_steps: int = 1024,
-    n_total_steps: int = 1024 * 10000,
-    act_reward_coef: float = 0.001,
-    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
-    bdconfig_path: Path = PROJECT_ROOT / "config/bd/20230530-a035-e020.toml",
-    gopsconfig_path: Path = PROJECT_ROOT / "config/gops/20240111-mutation-0401.toml",
-    env_override: str = "",
-    birth_override: str = "",
-    hazard_override: str = "",
-    reward_mask: str = "11111",
-    reward_fn: RewardKind = RewardKind.LINEAR,
-    logdir: Path = Path("./log"),
-    log_mode: LogMode = LogMode.FULL,
-    log_interval: int = 1000,
-    savestate_interval: int = 1000,
-    debug_vis: bool = False,
-) -> None:
-    # Load config
-    with cfconfig_path.open("r") as f:
-        cfconfig = toml.from_toml(CfConfig, f.read())
-    with bdconfig_path.open("r") as f:
-        bdconfig = toml.from_toml(BDConfig, f.read())
-    with gopsconfig_path.open("r") as f:
-        gopsconfig = toml.from_toml(GopsConfig, f.read())
-
-    # Apply overrides
-    cfconfig.apply_override(env_override)
-    bdconfig.apply_birth_override(birth_override)
-    bdconfig.apply_hazard_override(hazard_override)
-
-    # Load models
-    birth_fn, hazard_fn = bdconfig.load_models()
-    mutation = gopsconfig.load_model()
-    # Override config
-    cfconfig.n_initial_agents = n_agents
-    cfconfig.init_energy = init_energy
-    cfconfig.force_energy_consumption = action_cost
-    gopsconfig.params["mutation_prob"] = mutation_prob
-    # Make env
-    env = make("CircleForaging-v1", **dataclasses.asdict(cfconfig))
-    key, reward_key = jax.random.split(jax.random.PRNGKey(seed))
-    reward_extracor = RewardExtractor(
-        act_space=env.act_space,  # type: ignore
-        act_coef=act_reward_coef,
-        smell_coef=0.01,
-        mask=reward_mask,
-    )
-    common_rewardfn_args = {
-        "key": reward_key,
-        "n_agents": cfconfig.n_max_agents,
-        "n_weights": 5,
-        "std": gopsconfig.init_std,
-        "mean": gopsconfig.init_mean,
-    }
-    if reward_fn == RewardKind.LINEAR:
-        reward_fn_instance = LinearReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_linear,
-            serializer=linear_reward_serializer,
-        )
-    elif reward_fn == RewardKind.EXPONENTIAL:
-        reward_fn_instance = ExponentialReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_linear,
-            serializer=exp_reward_serializer,
-        )
-    elif reward_fn == RewardKind.SIGMOID:
-        reward_fn_instance = SigmoidReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=sigmoid_reward_serializer,
-        )
-    elif reward_fn == RewardKind.SIGMOID_01:
-        reward_fn_instance = SigmoidReward_01(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=sigmoid_reward_serializer,
-        )
-    elif reward_fn == RewardKind.SINH:
-        reward_fn_instance = SinhReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_linear,
-            serializer=linear_reward_serializer,
-        )
-    else:
-        raise ValueError(f"Invalid reward_fn {reward_fn}")
-
-    logger = Logger(
-        logdir=logdir,
-        mode=log_mode,
-        log_interval=log_interval,
-        savestate_interval=savestate_interval,
-    )
-    run_evolution(
-        key=key,
-        env=env,
-        n_initial_agents=n_agents,
-        adam=optax.adam(adam_lr, eps=adam_eps),
-        gamma=gamma,
-        gae_lambda=gae_lambda,
-        n_optim_epochs=n_optim_epochs,
-        minibatch_size=minibatch_size,
-        n_rollout_steps=n_rollout_steps,
-        n_total_steps=n_total_steps,
-        reward_fn=reward_fn_instance,
-        hazard_fn=hazard_fn,
-        birth_fn=birth_fn,
-        mutation=cast(gops.Mutation, mutation),
-        xmax=cfconfig.xlim[1],
-        ymax=cfconfig.ylim[1],
-        logger=logger,
-        debug_vis=debug_vis,
-    )
-
-
-@app.command()
-def replay(
-    physstate_path: Path,
-    backend: str = "pyglet",  # Use "headless" for headless rendering
-    videopath: Optional[Path] = None,
-    start: int = 0,
-    end: Optional[int] = None,
-    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
-    env_override: str = "",
-) -> None:
-    with cfconfig_path.open("r") as f:
-        cfconfig = toml.from_toml(CfConfig, f.read())
-    # For speedup
-    cfconfig.n_initial_agents = 1
-    cfconfig.apply_override(env_override)
-    phys_state = SavedPhysicsState.load(physstate_path)
-    env = make("CircleForaging-v1", **dataclasses.asdict(cfconfig))
-    env_state, _ = env.reset(jax.random.PRNGKey(0))
-    end_index = end if end is not None else phys_state.circle_axy.shape[0]
-    visualizer = env.visualizer(
-        env_state,
-        figsize=(cfconfig.xlim[1] * 2, cfconfig.ylim[1] * 2),
-        backend=backend,
-    )
-    if videopath is not None:
-        visualizer = SaveVideoWrapper(visualizer, videopath, fps=60)
-    for i in range(start, end_index):
-        phys = phys_state.set_by_index(i, env_state.physics)
-        env_state = dataclasses.replace(env_state, physics=phys)
-        visualizer.render(env_state.physics)
-        visualizer.show()
-    visualizer.close()
-
-
-@app.command()
-def widget(
-    physstate_path: Path,
-    start: int = 0,
-    end: Optional[int] = None,
-    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
-    log_offset: int = 0,
-    log_path: Optional[Path] = None,
-    self_terminate: bool = False,
-    profile_and_rewards_path: Optional[Path] = None,
-    cm_fixed_minmax: str = "",
-    env_override: str = "",
-) -> None:
-    from emevo.analysis.qt_widget import CFEnvReplayWidget, start_widget
-
-    with cfconfig_path.open("r") as f:
-        cfconfig = toml.from_toml(CfConfig, f.read())
-    # For speedup
-    cfconfig.n_initial_agents = 1
-    cfconfig.apply_override(env_override)
-    phys_state = SavedPhysicsState.load(physstate_path)
-    env = make("CircleForaging-v1", **dataclasses.asdict(cfconfig))
-    end = phys_state.circle_axy.shape[0] if end is None else end
-    if log_path is None:
-        log_ds = None
-        step_offset = 0
-    else:
-        import pyarrow.dataset as ds
-
-        log_ds = ds.dataset(log_path)
-        first_step = log_ds.scanner(columns=["step"]).head(1)["step"][0].as_py()
-        step_offset = first_step + log_offset
-
-    if profile_and_rewards_path is None:
-        profile_and_rewards = None
-    else:
-        import pyarrow.parquet as pq
-
-        profile_and_rewards = pq.read_table(profile_and_rewards_path)
-
-    if len(cm_fixed_minmax) > 0:
-        cm_fixed_minmax_dict = json.loads(cm_fixed_minmax)
-    else:
-        cm_fixed_minmax_dict = {}
-
-    start_widget(
-        CFEnvReplayWidget,
-        xlim=int(cfconfig.xlim[1]),
-        ylim=int(cfconfig.ylim[1]),
-        env=env,
-        saved_physics=phys_state,
-        start=start,
-        end=end,
-        log_ds=log_ds,
-        step_offset=step_offset,
-        self_terminate=self_terminate,
-        profile_and_rewards=profile_and_rewards,
-        cm_fixed_minmax=cm_fixed_minmax_dict,
-    )
-
-
-if __name__ == "__main__":
-    app()

From 4dd3595d0d81140143db3ab7d7bfbc9419fe0b3b Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 17 Feb 2024 17:32:07 +0900
Subject: [PATCH 267/337] Tweak on 4season

---
 config/env/20240216-4seasons.toml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/config/env/20240216-4seasons.toml b/config/env/20240216-4seasons.toml
index 375f2800..7f2efd9c 100644
--- a/config/env/20240216-4seasons.toml
+++ b/config/env/20240216-4seasons.toml
@@ -5,7 +5,11 @@ food_num_fn = ["logistic", 20, 0.01, 60]
 food_loc_fn = [
    "scheduled",
    1024000,
-   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["gaussian-mixture",
+       [0.5, 0.5],
+       [[360.0, 180.0], [120.0, 180.0]],
+       [[48.0, 36.0], [48.0, 36.0]],
+   ]
    ["switching",
        1000,
        ["gaussian", [360.0, 180.0], [48.0, 36.0]],

From bfb2fa58c6f76ada92a8db168417f7e06fb029f0 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 17 Feb 2024 18:42:13 +0900
Subject: [PATCH 268/337] const large

---
 config/env/20240217-const-large.toml | 29 ++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 config/env/20240217-const-large.toml

diff --git a/config/env/20240217-const-large.toml b/config/env/20240217-const-large.toml
new file mode 100644
index 00000000..c1f748fc
--- /dev/null
+++ b/config/env/20240217-const-large.toml
@@ -0,0 +1,29 @@
+n_initial_agents = 50
+n_max_agents = 200
+n_max_foods = 50
+food_num_fn = ["constant", 50]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 540.0]
+ylim = [0.0, 450.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From a126b015bbbc6c98c17c33062a8f4c7a982b2549 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 17 Feb 2024 19:24:23 +0900
Subject: [PATCH 269/337] Tweak on 4season

---
 config/env/20240216-4seasons.toml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/config/env/20240216-4seasons.toml b/config/env/20240216-4seasons.toml
index 7f2efd9c..28ae2040 100644
--- a/config/env/20240216-4seasons.toml
+++ b/config/env/20240216-4seasons.toml
@@ -1,7 +1,7 @@
 n_initial_agents = 50
 n_max_agents = 150
-n_max_foods = 60
-food_num_fn = ["logistic", 20, 0.01, 60]
+n_max_foods = 80
+food_num_fn = ["logistic", 40, 0.01, 80]
 food_loc_fn = [
    "scheduled",
    1024000,

From b98cf371cbc95c95fd116d46519cacf30d87ce7e Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 17 Feb 2024 19:24:31 +0900
Subject: [PATCH 270/337] Make poison work

---
 config/env/20240216-poison.toml           |  9 +--
 experiments/cf_asexual_evo.py             | 54 ++++++++++++---
 experiments/cfs_as_evo.py                 | 81 +++++++++++++++++++----
 src/emevo/environments/circle_foraging.py |  4 +-
 src/emevo/exp_utils.py                    |  1 +
 5 files changed, 121 insertions(+), 28 deletions(-)

diff --git a/config/env/20240216-poison.toml b/config/env/20240216-poison.toml
index 045173b8..0a81310b 100644
--- a/config/env/20240216-poison.toml
+++ b/config/env/20240216-poison.toml
@@ -1,18 +1,19 @@
 n_initial_agents = 50
 n_max_agents = 150
-n_max_foods = 60
+n_max_foods = 80
 n_food_sources = 2
 food_num_fn = [
-    ["logistic", 20, 0.01, 40],
+    ["logistic", 20, 0.01, 60],
     ["logistic", 10, 0.01, 20],
 ]
 food_loc_fn = [
-   ["gaussian", [300.0, 180.0], [48.0, 36.0]],
-   ["gaussian", [180.0, 180.0], [48.0, 36.0]],
+   ["gaussian", [320.0, 180.0], [48.0, 36.0]],
+   ["gaussian", [160.0, 180.0], [48.0, 36.0]],
 ]
 food_color = [[254, 2, 162, 255], [2, 254, 162, 255]]
 food_energy_coef = [1.0, -0.1]
 agent_loc_fn = "uniform"
+observe_food_label = true
 xlim = [0.0, 480.0]
 ylim = [0.0, 360.0]
 env_shape = "square"
diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index cd8d8a01..a8b11c61 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -106,11 +106,11 @@ def extract_sigmoid(
         return reward_input * self._mask_array, energy
 
 
-def linear_reward_serializer(w: jax.Array) -> dict[str, jax.Array]:
+def linear_rs(w: jax.Array) -> dict[str, jax.Array]:
     return serialize_weight(w, ["agent", "food", "wall", "action"])
 
 
-def exp_reward_serializer(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
+def exp_rs(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
     w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
     scale_dict = serialize_weight(
         scale,
@@ -119,7 +119,7 @@ def exp_reward_serializer(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array
     return w_dict | scale_dict
 
 
-def sigmoid_reward_serializer(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
+def sigmoid_rs(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
     w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
     alpha_dict = serialize_weight(
         alpha,
@@ -128,6 +128,33 @@ def sigmoid_reward_serializer(w: jax.Array, alpha: jax.Array) -> dict[str, jax.A
     return w_dict | alpha_dict
 
 
+def linear_rs_withp(w: jax.Array) -> dict[str, jax.Array]:
+    return serialize_weight(w, ["agent", "food", "poison", "wall", "action"])
+
+
+def exp_rs_withp(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
+    w_dict = serialize_weight(
+        w,
+        ["w_agent", "w_food", "w_poison", "w_wall", "w_action"],
+    )
+    scale_dict = serialize_weight(
+        scale,
+        ["scale_agent", "scale_food", "scale_poison", "scale_wall", "scale_action"],
+    )
+    return w_dict | scale_dict
+
+
+def sigmoid_rs_withp(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
+    w_dict = serialize_weight(
+        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
+    )
+    alpha_dict = serialize_weight(
+        alpha,
+        ["alpha_agent", "alpha_food", "w_poison", "alpha_wall", "alpha_action"],
+    )
+    return w_dict | alpha_dict
+
+
 def exec_rollout(
     state: State,
     initial_obs: Obs,
@@ -421,12 +448,13 @@ def evolve(
     env_override: str = "",
     birth_override: str = "",
     hazard_override: str = "",
-    reward_mask: str = "1111",
+    reward_mask: Optional[str] = None,
     reward_fn: RewardKind = RewardKind.LINEAR,
     logdir: Path = Path("./log"),
     log_mode: LogMode = LogMode.FULL,
     log_interval: int = 1000,
     savestate_interval: int = 1000,
+    poison_reward: bool = False,
     debug_vis: bool = False,
 ) -> None:
     # Load config
@@ -442,6 +470,12 @@ def evolve(
     bdconfig.apply_birth_override(birth_override)
     bdconfig.apply_hazard_override(hazard_override)
 
+    if reward_mask is None:
+        if poison_reward:
+            reward_mask = "11111"
+        else:
+            reward_mask = "1111"
+
     # Load models
     birth_fn, hazard_fn = bdconfig.load_models()
     mutation = gopsconfig.load_model()
@@ -461,7 +495,7 @@ def evolve(
     common_rewardfn_args = {
         "key": reward_key,
         "n_agents": cfconfig.n_max_agents,
-        "n_weights": 4,
+        "n_weights": 5 if poison_reward else 4,
         "std": gopsconfig.init_std,
         "mean": gopsconfig.init_mean,
     }
@@ -469,31 +503,31 @@ def evolve(
         reward_fn_instance = LinearReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_linear,
-            serializer=linear_reward_serializer,
+            serializer=linear_rs_withp if poison_reward else linear_rs,
         )
     elif reward_fn == RewardKind.EXPONENTIAL:
         reward_fn_instance = ExponentialReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_linear,
-            serializer=exp_reward_serializer,
+            serializer=exp_rs_withp if poison_reward else exp_rs,
         )
     elif reward_fn == RewardKind.SIGMOID:
         reward_fn_instance = SigmoidReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_sigmoid,
-            serializer=sigmoid_reward_serializer,
+            serializer=sigmoid_rs_withp if poison_reward else sigmoid_rs,
         )
     elif reward_fn == RewardKind.SIGMOID_01:
         reward_fn_instance = SigmoidReward_01(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_sigmoid,
-            serializer=sigmoid_reward_serializer,
+            serializer=sigmoid_rs_withp if poison_reward else sigmoid_rs,
         )
     elif reward_fn == RewardKind.SINH:
         reward_fn_instance = SinhReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_linear,
-            serializer=linear_reward_serializer,
+            serializer=linear_rs_withp if poison_reward else linear_rs,
         )
     else:
         raise ValueError(f"Invalid reward_fn {reward_fn}")
diff --git a/experiments/cfs_as_evo.py b/experiments/cfs_as_evo.py
index 36e5dbd6..80798104 100644
--- a/experiments/cfs_as_evo.py
+++ b/experiments/cfs_as_evo.py
@@ -96,7 +96,10 @@ def extract_linear(
         del energy
         act_input = self.act_coef * self.normalize_action(action)
         smell_input = self.smell_coef * smell
-        return jnp.concatenate((collision, act_input, smell_input), axis=1) * self._mask_array
+        return (
+            jnp.concatenate((collision, act_input, smell_input), axis=1)
+            * self._mask_array
+        )
 
     def extract_sigmoid(
         self,
@@ -111,11 +114,11 @@ def extract_sigmoid(
         return reward_input * self._mask_array, energy
 
 
-def linear_reward_serializer(w: jax.Array) -> dict[str, jax.Array]:
-    return serialize_weight(w, ["agent", "food", "wall", "action", "smell"])
+def linear_rs(w: jax.Array) -> dict[str, jax.Array]:
+    return serialize_weight(w, ["agent", "food", "poison", "wall", "action", "smell"])
 
 
-def exp_reward_serializer(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
+def exp_rs(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
     w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action", "w_smell"])
     scale_dict = serialize_weight(
         scale,
@@ -124,7 +127,7 @@ def exp_reward_serializer(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array
     return w_dict | scale_dict
 
 
-def sigmoid_reward_serializer(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
+def sigmoid_rs(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
     w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action", "w_smell"])
     alpha_dict = serialize_weight(
         alpha,
@@ -133,6 +136,53 @@ def sigmoid_reward_serializer(w: jax.Array, alpha: jax.Array) -> dict[str, jax.A
     return w_dict | alpha_dict
 
 
+def linear_rs_withp(w: jax.Array) -> dict[str, jax.Array]:
+    return serialize_weight(
+        w,
+        ["agent", "food", "poison", "wall", "action", "fsmell", "psmell"],
+    )
+
+
+def exp_rs_withp(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
+    w_dict = serialize_weight(
+        w,
+        ["w_agent", "w_food", "w_poison", "w_wall", "w_action", "w_fsmell", "w_psmell"],
+    )
+    scale_dict = serialize_weight(
+        scale,
+        [
+            "scale_agent",
+            "scale_food",
+            "scale_poison",
+            "scale_wall",
+            "scale_action",
+            "scale_fsmell",
+            "scale_psmell",
+        ],
+    )
+    return w_dict | scale_dict
+
+
+def sigmoid_rs_withp(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
+    w_dict = serialize_weight(
+        w,
+        ["w_agent", "w_food", "w_poison", "w_wall", "w_action", "w_fsmell", "w_psmell"],
+    )
+    alpha_dict = serialize_weight(
+        alpha,
+        [
+            "alpha_agent",
+            "alpha_food",
+            "alpha_poison",
+            "alpha_wall",
+            "alpha_action",
+            "alpha_fsmell",
+            "alpha_psmell",
+        ],
+    )
+    return w_dict | alpha_dict
+
+
 def exec_rollout(
     state: State,
     initial_obs: Obs,
@@ -427,12 +477,13 @@ def evolve(
     env_override: str = "",
     birth_override: str = "",
     hazard_override: str = "",
-    reward_mask: str = "11111",
+    reward_mask: Optional[str] = None,
     reward_fn: RewardKind = RewardKind.LINEAR,
     logdir: Path = Path("./log"),
     log_mode: LogMode = LogMode.FULL,
     log_interval: int = 1000,
     savestate_interval: int = 1000,
+    poison_reward: bool = False,
     debug_vis: bool = False,
 ) -> None:
     # Load config
@@ -448,6 +499,12 @@ def evolve(
     bdconfig.apply_birth_override(birth_override)
     bdconfig.apply_hazard_override(hazard_override)
 
+    if reward_mask is None:
+        if poison_reward:
+            reward_mask = "1111111"
+        else:
+            reward_mask = "11111"
+
     # Load models
     birth_fn, hazard_fn = bdconfig.load_models()
     mutation = gopsconfig.load_model()
@@ -468,7 +525,7 @@ def evolve(
     common_rewardfn_args = {
         "key": reward_key,
         "n_agents": cfconfig.n_max_agents,
-        "n_weights": 5,
+        "n_weights": 7 if poison_reward else 5,
         "std": gopsconfig.init_std,
         "mean": gopsconfig.init_mean,
     }
@@ -476,31 +533,31 @@ def evolve(
         reward_fn_instance = LinearReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_linear,
-            serializer=linear_reward_serializer,
+            serializer=linear_rs_withp if poison_reward else linear_rs,
         )
     elif reward_fn == RewardKind.EXPONENTIAL:
         reward_fn_instance = ExponentialReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_linear,
-            serializer=exp_reward_serializer,
+            serializer=exp_rs_withp if poison_reward else exp_rs,
         )
     elif reward_fn == RewardKind.SIGMOID:
         reward_fn_instance = SigmoidReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_sigmoid,
-            serializer=sigmoid_reward_serializer,
+            serializer=sigmoid_rs_withp if poison_reward else sigmoid_rs,
         )
     elif reward_fn == RewardKind.SIGMOID_01:
         reward_fn_instance = SigmoidReward_01(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_sigmoid,
-            serializer=sigmoid_reward_serializer,
+            serializer=sigmoid_rs_withp if poison_reward else sigmoid_rs,
         )
     elif reward_fn == RewardKind.SINH:
         reward_fn_instance = SinhReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_linear,
-            serializer=linear_reward_serializer,
+            serializer=linear_rs_withp if poison_reward else linear_rs,
         )
     else:
         raise ValueError(f"Invalid reward_fn {reward_fn}")
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 81bd0db3..83bdab11 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -585,7 +585,7 @@ def food_collision_with_labels(
                 c2sc: jax.Array,
                 label: jax.Array,
             ) -> jax.Array:
-                onehot = jax.nn.one_hot(label, self._n_food_sources)  # (FOOD, LABEL)
+                onehot = jax.nn.one_hot(label, self._n_food_sources, dtype=bool)
                 expanded_c2sc = jnp.expand_dims(c2sc, axis=2)  # (AGENT, FOOD, 1)
                 expanded_onehot = jnp.expand_dims(onehot, axis=0)  # (1, FOOD, LABEL)
                 return jnp.max(expanded_c2sc * expanded_onehot, axis=1)
@@ -879,7 +879,7 @@ def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
         sensor_obs = self._sensor_obs(stated=physics)
         obs = CFObs(
             sensor=sensor_obs.reshape(-1, self._n_sensors, self._n_obj),
-            collision=jnp.zeros((N, N_OBJECTS), dtype=bool),
+            collision=jnp.zeros((N, self._n_obj), dtype=bool),
             angle=physics.circle.p.angle,
             velocity=physics.circle.v.xy,
             angular_velocity=physics.circle.v.angle,
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 28823396..ef97a235 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -70,6 +70,7 @@ class CfConfig:
     smell_decay_factor: float = 0.01
     smell_diff_max: float = 1.0
     smell_diff_coef: float = 100.0
+    observe_food_label: bool = False
 
     def apply_override(self, override: str) -> None:
         if 0 < len(override):

From 541df89c67b4b61e3fab11edf4229ead187e8e8f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 17 Feb 2024 19:39:30 +0900
Subject: [PATCH 271/337] 4season easy

---
 config/env/20240216-4seasons.toml      | 10 ++----
 config/env/20240217-4seasons-easy.toml | 44 ++++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 7 deletions(-)
 create mode 100644 config/env/20240217-4seasons-easy.toml

diff --git a/config/env/20240216-4seasons.toml b/config/env/20240216-4seasons.toml
index 28ae2040..375f2800 100644
--- a/config/env/20240216-4seasons.toml
+++ b/config/env/20240216-4seasons.toml
@@ -1,15 +1,11 @@
 n_initial_agents = 50
 n_max_agents = 150
-n_max_foods = 80
-food_num_fn = ["logistic", 40, 0.01, 80]
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
 food_loc_fn = [
    "scheduled",
    1024000,
-   ["gaussian-mixture",
-       [0.5, 0.5],
-       [[360.0, 180.0], [120.0, 180.0]],
-       [[48.0, 36.0], [48.0, 36.0]],
-   ]
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
    ["switching",
        1000,
        ["gaussian", [360.0, 180.0], [48.0, 36.0]],
diff --git a/config/env/20240217-4seasons-easy.toml b/config/env/20240217-4seasons-easy.toml
new file mode 100644
index 00000000..28ae2040
--- /dev/null
+++ b/config/env/20240217-4seasons-easy.toml
@@ -0,0 +1,44 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 80
+food_num_fn = ["logistic", 40, 0.01, 80]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian-mixture",
+       [0.5, 0.5],
+       [[360.0, 180.0], [120.0, 180.0]],
+       [[48.0, 36.0], [48.0, 36.0]],
+   ]
+   ["switching",
+       1000,
+       ["gaussian", [360.0, 180.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 180.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 90.0], [48.0, 36.0]],
+   ],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From a6332bdb621115328a9662c0254d01c1f651df76 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Sat, 17 Feb 2024 20:09:00 +0900
Subject: [PATCH 272/337] Fix 4seasons easy

---
 config/env/20240217-4seasons-easy.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config/env/20240217-4seasons-easy.toml b/config/env/20240217-4seasons-easy.toml
index 28ae2040..a5dbe53d 100644
--- a/config/env/20240217-4seasons-easy.toml
+++ b/config/env/20240217-4seasons-easy.toml
@@ -9,7 +9,7 @@ food_loc_fn = [
        [0.5, 0.5],
        [[360.0, 180.0], [120.0, 180.0]],
        [[48.0, 36.0], [48.0, 36.0]],
-   ]
+   ],
    ["switching",
        1000,
        ["gaussian", [360.0, 180.0], [48.0, 36.0]],

From c34f6e8f3131e896b74242d2a96657e01e7ecfec Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Sat, 17 Feb 2024 20:24:00 +0900
Subject: [PATCH 273/337] Fix const-large

---
 config/env/20240217-const-large.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config/env/20240217-const-large.toml b/config/env/20240217-const-large.toml
index c1f748fc..55b51cb0 100644
--- a/config/env/20240217-const-large.toml
+++ b/config/env/20240217-const-large.toml
@@ -1,6 +1,6 @@
 n_initial_agents = 50
 n_max_agents = 200
-n_max_foods = 50
+n_max_foods = 60
 food_num_fn = ["constant", 50]
 food_loc_fn = "gaussian"
 agent_loc_fn = "uniform"

From 2044cdccaa19ebc9baf14f53036a61247242dba2 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 20 Feb 2024 01:13:47 +0900
Subject: [PATCH 274/337] const cycle

---
 config/env/20240220-const-cycle.toml | 34 ++++++++++++++++++++++++++++
 src/emevo/environments/env_utils.py  | 31 +++++++++++++++++++++++++
 2 files changed, 65 insertions(+)
 create mode 100644 config/env/20240220-const-cycle.toml

diff --git a/config/env/20240220-const-cycle.toml b/config/env/20240220-const-cycle.toml
new file mode 100644
index 00000000..a21c6434
--- /dev/null
+++ b/config/env/20240220-const-cycle.toml
@@ -0,0 +1,34 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = [
+   "cycle",
+   10240,
+   ["constant", 40],
+   ["constant", 30],
+]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index a5fa3dd7..8b9d7d20 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -83,6 +83,34 @@ def __call__(self, _: int, state: FoodNumState) -> FoodNumState:
         dn_dt = self.growth_rate * internal * (1 - internal / self.capacity)
         return state._update(internal + dn_dt)
 
+class ReprNumCycle:
+    def __init__(
+        self,
+        interval: int,
+        *num_fns: tuple[str, ...] | ReprNumFn,
+    ) -> None:
+        numfn_list = []
+        for fn_or_base in num_fns:
+            if callable(fn_or_base):
+                numfn_list.append(fn_or_base)
+            else:
+                name, *args = fn_or_base
+                fn, _ = ReprNum(name)(*args)
+                numfn_list.append(fn)
+        self._numfn_list = numfn_list
+        self._n_fn = len(numfn_list)
+        self._interval = interval
+
+    @property
+    def initial(self) -> int:
+        return self._numfn_list[0].initial
+
+    def __call__(self, n_steps: int, state: FoodNumState) -> FoodNumState:
+        n = n_steps // self._interval
+        index = n % self._n_fn
+        return jax.lax.switch(index, self._numfn_list, n_steps, state)
+
+
 
 class ReprNumScheduled:
     """Branching based on steps."""
@@ -118,6 +146,7 @@ class ReprNum(str, enum.Enum):
     """Methods to determine the number of foods reproduced."""
 
     CONSTANT = "constant"
+    CYCLE = "cycle"
     LINEAR = "linear"
     LOGISTIC = "logistic"
     SCHEDULED = "scheduled"
@@ -125,6 +154,8 @@ class ReprNum(str, enum.Enum):
     def __call__(self, *args: Any, **kwargs: Any) -> tuple[ReprNumFn, FoodNumState]:
         if self is ReprNum.CONSTANT:
             fn = ReprNumConstant(*args, **kwargs)
+        elif self is ReprNum.CYCLE:
+            fn = ReprNumCycle(*args, **kwargs)
         elif self is ReprNum.LINEAR:
             fn = ReprNumLinear(*args, **kwargs)
         elif self is ReprNum.LOGISTIC:

From 63b815a2d5795718f59f9aebecabf83d9e9f21d0 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 20 Feb 2024 17:49:51 +0900
Subject: [PATCH 275/337] largevar

---
 config/env/20240220-largevar.toml | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 config/env/20240220-largevar.toml

diff --git a/config/env/20240220-largevar.toml b/config/env/20240220-largevar.toml
new file mode 100644
index 00000000..ed4ab90d
--- /dev/null
+++ b/config/env/20240220-largevar.toml
@@ -0,0 +1,29 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 50
+food_num_fn = ["logistic", 20, 0.01, 50]
+food_loc_fn = ["gaussian", [360.0, 270.0], [80.0, 60.0]]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 7c7bae1902bbcd6f2686aa58ed422d0f601e3a21 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 22 Feb 2024 18:04:00 +0900
Subject: [PATCH 276/337] Sigmoid exp

---
 experiments/cf_asexual_evo.py | 90 ++++++++++++++++++++++++-----------
 src/emevo/reward_fn.py        | 41 ++++++++++++++++
 2 files changed, 102 insertions(+), 29 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index a8b11c61..a9fb8b7e 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -18,6 +18,7 @@
 from emevo import birth_and_death as bd
 from emevo import genetic_ops as gops
 from emevo import make
+from emevo import reward_fn as rfn
 from emevo.env import ObsProtocol as Obs
 from emevo.env import StateProtocol as State
 from emevo.eqx_utils import get_slice
@@ -32,16 +33,6 @@
     SavedPhysicsState,
     SavedProfile,
 )
-from emevo.reward_fn import (
-    ExponentialReward,
-    LinearReward,
-    RewardFn,
-    SigmoidReward,
-    SigmoidReward_01,
-    SinhReward,
-    mutate_reward_fn,
-    serialize_weight,
-)
 from emevo.rl.ppo_normal import (
     NormalPPONet,
     Rollout,
@@ -62,6 +53,7 @@ class RewardKind(str, enum.Enum):
     EXPONENTIAL = "exponential"
     SIGMOID = "sigmoid"
     SIGMOID_01 = "sigmoid-01"
+    SIGMOID_EXP = "sigmoid-exp"
     SINH = "sinh"
 
 
@@ -107,12 +99,12 @@ def extract_sigmoid(
 
 
 def linear_rs(w: jax.Array) -> dict[str, jax.Array]:
-    return serialize_weight(w, ["agent", "food", "wall", "action"])
+    return rfn.serialize_weight(w, ["agent", "food", "wall", "action"])
 
 
 def exp_rs(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
-    w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
-    scale_dict = serialize_weight(
+    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    scale_dict = rfn.serialize_weight(
         scale,
         ["scale_agent", "scale_food", "scale_wall", "scale_action"],
     )
@@ -120,24 +112,41 @@ def exp_rs(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
 
 
 def sigmoid_rs(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
-    w_dict = serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
-    alpha_dict = serialize_weight(
+    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    alpha_dict = rfn.serialize_weight(
         alpha,
         ["alpha_agent", "alpha_food", "alpha_wall", "alpha_action"],
     )
     return w_dict | alpha_dict
 
 
+def sigmoid_exp_rs(
+    w: jax.Array,
+    scale: jax.Array,
+    alpha: jax.Array,
+) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    alpha_dict = rfn.serialize_weight(
+        alpha,
+        ["alpha_agent", "alpha_food", "alpha_wall", "alpha_action"],
+    )
+    scale_dict = rfn.serialize_weight(
+        scale,
+        ["scale_agent", "scale_food", "scale_wall", "scale_action"],
+    )
+    return (w_dict | alpha_dict) | scale_dict
+
+
 def linear_rs_withp(w: jax.Array) -> dict[str, jax.Array]:
-    return serialize_weight(w, ["agent", "food", "poison", "wall", "action"])
+    return rfn.serialize_weight(w, ["agent", "food", "poison", "wall", "action"])
 
 
 def exp_rs_withp(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
-    w_dict = serialize_weight(
+    w_dict = rfn.serialize_weight(
         w,
         ["w_agent", "w_food", "w_poison", "w_wall", "w_action"],
     )
-    scale_dict = serialize_weight(
+    scale_dict = rfn.serialize_weight(
         scale,
         ["scale_agent", "scale_food", "scale_poison", "scale_wall", "scale_action"],
     )
@@ -145,22 +154,39 @@ def exp_rs_withp(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
 
 
 def sigmoid_rs_withp(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
-    w_dict = serialize_weight(
+    w_dict = rfn.serialize_weight(
         w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
     )
-    alpha_dict = serialize_weight(
+    alpha_dict = rfn.serialize_weight(
         alpha,
         ["alpha_agent", "alpha_food", "w_poison", "alpha_wall", "alpha_action"],
     )
     return w_dict | alpha_dict
 
 
+def sigmoid_exp_rs_withp(
+    w: jax.Array, scale: jax.Array, alpha: jax.Array
+) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(
+        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
+    )
+    alpha_dict = rfn.serialize_weight(
+        alpha,
+        ["alpha_agent", "alpha_food", "w_poison", "alpha_wall", "alpha_action"],
+    )
+    scale_dict = rfn.serialize_weight(
+        scale,
+        ["scale_agent", "scale_food", "scale_poison", "scale_wall", "scale_action"],
+    )
+    return (w_dict | alpha_dict) | scale_dict
+
+
 def exec_rollout(
     state: State,
     initial_obs: Obs,
     env: Env,
     network: NormalPPONet,
-    reward_fn: RewardFn,
+    reward_fn: rfn.RewardFn,
     hazard_fn: bd.HazardFunction,
     birth_fn: bd.BirthFunction,
     prng_key: jax.Array,
@@ -238,7 +264,7 @@ def epoch(
     initial_obs: Obs,
     env: Env,
     network: NormalPPONet,
-    reward_fn: RewardFn,
+    reward_fn: rfn.RewardFn,
     hazard_fn: bd.HazardFunction,
     birth_fn: bd.BirthFunction,
     prng_key: jax.Array,
@@ -289,7 +315,7 @@ def run_evolution(
     minibatch_size: int,
     n_rollout_steps: int,
     n_total_steps: int,
-    reward_fn: RewardFn,
+    reward_fn: rfn.RewardFn,
     hazard_fn: bd.HazardFunction,
     birth_fn: bd.BirthFunction,
     mutation: gops.Mutation,
@@ -391,7 +417,7 @@ def replace_net(
             pponet, opt_state = replace_net(init_key, is_new, pponet, opt_state)
 
         # Mutation
-        reward_fn = mutate_reward_fn(
+        reward_fn = rfn.mutate_reward_fn(
             key,
             logger.reward_fn_dict,
             reward_fn,
@@ -500,31 +526,37 @@ def evolve(
         "mean": gopsconfig.init_mean,
     }
     if reward_fn == RewardKind.LINEAR:
-        reward_fn_instance = LinearReward(
+        reward_fn_instance = rfn.LinearReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_linear,
             serializer=linear_rs_withp if poison_reward else linear_rs,
         )
     elif reward_fn == RewardKind.EXPONENTIAL:
-        reward_fn_instance = ExponentialReward(
+        reward_fn_instance = rfn.ExponentialReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_linear,
             serializer=exp_rs_withp if poison_reward else exp_rs,
         )
     elif reward_fn == RewardKind.SIGMOID:
-        reward_fn_instance = SigmoidReward(
+        reward_fn_instance = rfn.SigmoidReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_sigmoid,
             serializer=sigmoid_rs_withp if poison_reward else sigmoid_rs,
         )
     elif reward_fn == RewardKind.SIGMOID_01:
-        reward_fn_instance = SigmoidReward_01(
+        reward_fn_instance = rfn.SigmoidReward_01(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_sigmoid,
             serializer=sigmoid_rs_withp if poison_reward else sigmoid_rs,
         )
+    elif reward_fn == RewardKind.SIGMOID_EXP:
+        reward_fn_instance = rfn.SigmoidExponentialReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=sigmoid_exp_rs_withp if poison_reward else sigmoid_exp_rs,
+        )
     elif reward_fn == RewardKind.SINH:
-        reward_fn_instance = SinhReward(
+        reward_fn_instance = rfn.SinhReward(
             **common_rewardfn_args,
             extractor=reward_extracor.extract_linear,
             serializer=linear_rs_withp if poison_reward else linear_rs,
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 5ea80384..2392123f 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -181,6 +181,47 @@ def __call__(self, *args) -> jax.Array:
         return jax.vmap(jnp.dot)(filtered, self.weight)
 
 
+class SigmoidExponentialReward(RewardFn):
+    weight: jax.Array
+    scale: jax.Array
+    alpha: jax.Array
+    extractor: Callable[..., tuple[jax.Array, jax.Array]]
+    serializer: Callable[[jax.Array, jax.Array, jax.Array], dict[str, jax.Array]]
+
+    def __init__(
+        self,
+        *,
+        key: chex.PRNGKey,
+        n_agents: int,
+        n_weights: int,
+        extractor: Callable[..., tuple[jax.Array, jax.Array]],
+        serializer: Callable[[jax.Array, jax.Array, jax.Array], dict[str, jax.Array]],
+        std: float = 1.0,
+        mean: float = 0.0,
+    ) -> None:
+        k1, k2 = jax.random.split(key)
+        self.weight = jax.random.normal(k1, (n_agents, n_weights)) * std + mean
+        self.scale = jax.random.normal(k2, (n_agents, n_weights)) * std + mean
+        self.alpha = jax.random.normal(k2, (n_agents, n_weights)) * std + mean
+        self.extractor = extractor
+        self.serializer = serializer
+
+    def __call__(self, *args) -> jax.Array:
+        extracted, energy = self.extractor(*args)
+        weight = (10**self.scale) * self.weight
+        e = energy.reshape(-1, 1)  # (N, n_weights)
+        alpha_plus = 2.0 * extracted / (1.0 + jnp.exp(-e * (1.0 - self.alpha))) - 1.0
+        alpha_minus = 2.0 * extracted / (1.0 + jnp.exp(-e * self.alpha))
+        filtered = jnp.where(self.alpha > 0, alpha_plus, alpha_minus)
+        return jax.vmap(jnp.dot)(filtered, weight)
+
+    def serialise(self) -> dict[str, float | NDArray]:
+        return jax.tree_map(
+            _item_or_np,
+            self.serializer(self.weight, self.scale, self.alpha),
+        )
+
+
 def mutate_reward_fn(
     key: chex.PRNGKey,
     reward_fn_dict: dict[int, RF],

From 7bc5f13d3961a4a4cb67aff3e00132ade6ffb682 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Thu, 22 Feb 2024 18:11:16 +0900
Subject: [PATCH 277/337] 0402

---
 config/gops/20240222-mutation-0402-clipped.toml | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 config/gops/20240222-mutation-0402-clipped.toml

diff --git a/config/gops/20240222-mutation-0402-clipped.toml b/config/gops/20240222-mutation-0402-clipped.toml
new file mode 100644
index 00000000..bda2b476
--- /dev/null
+++ b/config/gops/20240222-mutation-0402-clipped.toml
@@ -0,0 +1,15 @@
+path = "emevo.genetic_ops.BernoulliMixtureMutation"
+init_std = 0.1
+init_mean = 0.0
+
+[params]
+mutation_prob = 0.4
+
+[params.mutator]
+path = "emevo.genetic_ops.UniformMutation"
+
+[params.mutator.params]
+min_noise = -0.2
+max_noise = 0.2
+clip_min = -1.0
+clip_max = 1.0
\ No newline at end of file

From 9028cc5b0bc1d1044b56c1eea7b868a1106c42be Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 23 Feb 2024 15:51:48 +0900
Subject: [PATCH 278/337] largevar-cent

---
 config/env/20240223-largevar-cent.toml | 29 ++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 config/env/20240223-largevar-cent.toml

diff --git a/config/env/20240223-largevar-cent.toml b/config/env/20240223-largevar-cent.toml
new file mode 100644
index 00000000..c6eca94a
--- /dev/null
+++ b/config/env/20240223-largevar-cent.toml
@@ -0,0 +1,29 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = ["gaussian", [240.0, 180.0], [80.0, 60.0]]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 5784c6b88ef711c339dc1e40f35fe511dbc67388 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 24 Feb 2024 02:03:04 +0900
Subject: [PATCH 279/337] delayed-se reward

---
 .../gops/20240224-0401-clipped-delay40.toml   | 18 +++++
 experiments/cf_asexual_evo.py                 | 42 ++++++++++
 notebooks/reward_fn.ipynb                     | 77 +++++++++++++++----
 src/emevo/exp_utils.py                        |  1 +
 src/emevo/reward_fn.py                        | 45 +++++++++++
 5 files changed, 170 insertions(+), 13 deletions(-)
 create mode 100644 config/gops/20240224-0401-clipped-delay40.toml

diff --git a/config/gops/20240224-0401-clipped-delay40.toml b/config/gops/20240224-0401-clipped-delay40.toml
new file mode 100644
index 00000000..a273474d
--- /dev/null
+++ b/config/gops/20240224-0401-clipped-delay40.toml
@@ -0,0 +1,18 @@
+path = "emevo.genetic_ops.BernoulliMixtureMutation"
+init_std = 0.1
+init_mean = 0.0
+
+[init_kwargs]
+delay_scale = 40.0
+
+[params]
+mutation_prob = 0.4
+
+[params.mutator]
+path = "emevo.genetic_ops.UniformMutation"
+
+[params.mutator.params]
+min_noise = -0.1
+max_noise = 0.1
+clip_min = -1.0
+clip_max = 1.0
\ No newline at end of file
diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index a9fb8b7e..6452e9ec 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -49,6 +49,7 @@
 
 
 class RewardKind(str, enum.Enum):
+    DELAYED_SE = "delayed-se"
     LINEAR = "linear"
     EXPONENTIAL = "exponential"
     SIGMOID = "sigmoid"
@@ -137,6 +138,23 @@ def sigmoid_exp_rs(
     return (w_dict | alpha_dict) | scale_dict
 
 
+def delayed_se_rs(
+    w: jax.Array,
+    scale: jax.Array,
+    delay: jax.Array,
+) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    delay_dict = rfn.serialize_weight(
+        delay,
+        ["delay_agent", "delay_food", "delay_wall", "delay_action"],
+    )
+    scale_dict = rfn.serialize_weight(
+        scale,
+        ["scale_agent", "scale_food", "scale_wall", "scale_action"],
+    )
+    return (w_dict | delay_dict) | scale_dict
+
+
 def linear_rs_withp(w: jax.Array) -> dict[str, jax.Array]:
     return rfn.serialize_weight(w, ["agent", "food", "poison", "wall", "action"])
 
@@ -181,6 +199,23 @@ def sigmoid_exp_rs_withp(
     return (w_dict | alpha_dict) | scale_dict
 
 
+def delayed_se_rs_withp(
+    w: jax.Array, scale: jax.Array, delay: jax.Array
+) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(
+        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
+    )
+    delay_dict = rfn.serialize_weight(
+        delay,
+        ["delay_agent", "delay_food", "w_poison", "delay_wall", "delay_action"],
+    )
+    scale_dict = rfn.serialize_weight(
+        scale,
+        ["scale_agent", "scale_food", "scale_poison", "scale_wall", "scale_action"],
+    )
+    return (w_dict | delay_dict) | scale_dict
+
+
 def exec_rollout(
     state: State,
     initial_obs: Obs,
@@ -525,6 +560,7 @@ def evolve(
         "std": gopsconfig.init_std,
         "mean": gopsconfig.init_mean,
     }
+    common_rewardfn_args |= gopsconfig.init_kwargs
     if reward_fn == RewardKind.LINEAR:
         reward_fn_instance = rfn.LinearReward(
             **common_rewardfn_args,
@@ -555,6 +591,12 @@ def evolve(
             extractor=reward_extracor.extract_sigmoid,
             serializer=sigmoid_exp_rs_withp if poison_reward else sigmoid_exp_rs,
         )
+    elif reward_fn == RewardKind.DELAYED_SE:
+        reward_fn_instance = rfn.DelayedSEReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=delayed_se_rs_withp if poison_reward else delayed_se_rs,
+        )
     elif reward_fn == RewardKind.SINH:
         reward_fn_instance = rfn.SinhReward(
             **common_rewardfn_args,
diff --git a/notebooks/reward_fn.ipynb b/notebooks/reward_fn.ipynb
index 16e9fdd8..9bb70845 100644
--- a/notebooks/reward_fn.ipynb
+++ b/notebooks/reward_fn.ipynb
@@ -53,7 +53,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 3,
    "id": "df0fe701-8b83-4a0c-86f9-6d241cd930ea",
    "metadata": {},
    "outputs": [],
@@ -93,14 +93,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 4,
    "id": "a9fbd4a3-b9ef-437d-8db6-3771d6b1fef0",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "571063db72b14c0d81aa156da8ec2aa6",
+       "model_id": "04c0cf339f8b47ae9d6454dd93fc68b9",
        "version_major": 2,
        "version_minor": 0
       },
@@ -108,25 +108,25 @@
        "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=1.0, min=-1.0, step=0.002…"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "f8660c8cb8b243dc984aba79588a9a51",
+       "model_id": "404bc3cf71754f1598e3e067e555cc6d",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -144,14 +144,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 6,
    "id": "64594795-61ee-46f9-b8f0-35325a5e2f56",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "15f80edb7c334784a2719be036347b2a",
+       "model_id": "5f94de4e010c4f8bbb7b859ac3aa14c7",
        "version_major": 2,
        "version_minor": 0
       },
@@ -159,25 +159,25 @@
        "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=1.0, min=-1.0, step=0.002…"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "35eaa9d03a664a9fb725df6d2b14390a",
+       "model_id": "6a67a65bfa694280b5691854f9aee028",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -193,6 +193,57 @@
     "sigmoid_reward_widget(lambda e, a: 2.0 / (1.0 + np.exp(- e * a)) - (a > 0))"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "10645fdc-831b-4e82-82c3-06066eafb08d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "17d3c9dc1aad41ceb0b3767a7fd9836c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=1.0, min=-1.0, step=0.002…"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6c62d5c5257c4942b14a032e6761d5b8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sigmoid_reward_widget(lambda e, a: 1.0 / (1.0 + np.exp(e * (a < 0) - e * (a > 0) + 20 * a)))"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 30,
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index ef97a235..1b7eb0f9 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -128,6 +128,7 @@ class GopsConfig:
     init_std: float
     init_mean: float
     params: Dict[str, Union[float, Dict[str, float]]]
+    init_kwargs: Dict[str, float] = dataclasses.field(default_factory=dict)
 
     def load_model(self) -> gops.Mutation | gops.Crossover:
         params = {}
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 2392123f..750ad953 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -222,6 +222,51 @@ def serialise(self) -> dict[str, float | NDArray]:
         )
 
 
+class DelayedSEReward(RewardFn):
+    weight: jax.Array
+    scale: jax.Array
+    delay: jax.Array
+    extractor: Callable[..., tuple[jax.Array, jax.Array]]
+    serializer: Callable[[jax.Array, jax.Array, jax.Array], dict[str, jax.Array]]
+    delay_scale: float
+
+    def __init__(
+        self,
+        *,
+        key: chex.PRNGKey,
+        n_agents: int,
+        n_weights: int,
+        extractor: Callable[..., tuple[jax.Array, jax.Array]],
+        serializer: Callable[[jax.Array, jax.Array, jax.Array], dict[str, jax.Array]],
+        std: float = 1.0,
+        mean: float = 0.0,
+        delay_scale: float = 20.0,
+    ) -> None:
+        k1, k2 = jax.random.split(key)
+        self.weight = jax.random.normal(k1, (n_agents, n_weights)) * std + mean
+        self.scale = jax.random.normal(k2, (n_agents, n_weights)) * std + mean
+        self.delay = jax.random.normal(k2, (n_agents, n_weights)) * std + mean
+        self.extractor = extractor
+        self.serializer = serializer
+        self.delay_scale = delay_scale
+
+    def __call__(self, *args) -> jax.Array:
+        extracted, energy = self.extractor(*args)
+        weight = (10**self.scale) * self.weight
+        e = energy.reshape(-1, 1)  # (N, n_weights)
+        exp = jnp.exp(
+            e * (self.delay < 0) - e * (self.delay > 0) + self.delay_scale * self.delay
+        )
+        filtered = extracted / (1.0 + exp)
+        return jax.vmap(jnp.dot)(filtered, weight)
+
+    def serialise(self) -> dict[str, float | NDArray]:
+        return jax.tree_map(
+            _item_or_np,
+            self.serializer(self.weight, self.scale, self.delay),
+        )
+
+
 def mutate_reward_fn(
     key: chex.PRNGKey,
     reward_fn_dict: dict[int, RF],

From 44b1dc7d44cd42758cc49bd6605e8f0152ea5ffb Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 24 Feb 2024 15:10:41 +0900
Subject: [PATCH 280/337] thinner sensor

---
 src/emevo/environments/moderngl_vis.py | 59 +-------------------------
 1 file changed, 2 insertions(+), 57 deletions(-)

diff --git a/src/emevo/environments/moderngl_vis.py b/src/emevo/environments/moderngl_vis.py
index facd527e..f18646da 100644
--- a/src/emevo/environments/moderngl_vis.py
+++ b/src/emevo/environments/moderngl_vis.py
@@ -90,61 +90,6 @@
 """
 
 
-_ARROW_GEOMETRY_SHADER = """
-#version 330
-layout (lines) in;
-layout (triangle_strip, max_vertices = 7) out;
-uniform mat4 proj;
-void main() {
-    vec2 a = gl_in[0].gl_Position.xy;
-    vec2 b = gl_in[1].gl_Position.xy;
-    vec2 a2b = b - a;
-    float a2b_len = length(a2b);
-    float width = min(0.004, a2b_len * 0.12);
-    vec2 a2left = vec2(-a2b.y, a2b.x) / length(a2b) * width;
-    vec2 c = a + a2b * 0.5;
-    vec2 c2head = a2left * 2.5;
-
-    vec4 positions[7] = vec4[7](
-        vec4(a - a2left, 0.0, 1.0),
-        vec4(a + a2left, 0.0, 1.0),
-        vec4(c - a2left, 0.0, 1.0),
-        vec4(c + a2left, 0.0, 1.0),
-        vec4(c - c2head, 0.0, 1.0),
-        vec4(b, 0.0, 1.0),
-        vec4(c + c2head, 0.0, 1.0)
-    );
-    for (int i = 0; i < 7; ++i) {
-        gl_Position = positions[i];
-        EmitVertex();
-    }
-    EndPrimitive();
-}
-"""
-
-_TEXTURE_VERTEX_SHADER = """
-#version 330
-uniform mat4 proj;
-in vec2 in_position;
-in vec2 in_uv;
-out vec2 uv;
-void main() {
-    gl_Position = proj * vec4(in_position, 0.0, 1.0);
-    uv = in_uv;
-}
-"""
-
-_TEXTURE_FRAGMENT_SHADER = """
-#version 330
-uniform sampler2D image;
-in vec2 uv;
-out vec4 f_color;
-void main() {
-    f_color = vec4(texture(image, uv).rgb, 1.0);
-}
-"""
-
-
 class Renderable:
     MODE: ClassVar[int]
     vertex_array: mgl.VertexArray
@@ -387,8 +332,8 @@ def __init__(
                 vertex_shader=_LINE_VERTEX_SHADER,
                 geometry_shader=_LINE_GEOMETRY_SHADER,
                 fragment_shader=_LINE_FRAGMENT_SHADER,
-                color=np.array([0.0, 0.0, 0.0, 0.2], dtype=np.float32),
-                width=np.array([0.002], dtype=np.float32),
+                color=np.array([0.0, 0.0, 0.0, 0.1], dtype=np.float32),
+                width=np.array([0.001], dtype=np.float32),
             )
 
             def collect_sensors(stated: StateDict) -> NDArray:

From 1b0e4721893c46d83a26a3121390e2044e009ffb Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 24 Feb 2024 15:22:27 +0900
Subject: [PATCH 281/337] ls env

---
 config/env/20240224-ls-4season.toml | 40 +++++++++++++++++++++++++++++
 config/env/20240224-ls-lvc.toml     | 29 +++++++++++++++++++++
 config/env/20240224-ls-square.toml  | 29 +++++++++++++++++++++
 3 files changed, 98 insertions(+)
 create mode 100644 config/env/20240224-ls-4season.toml
 create mode 100644 config/env/20240224-ls-lvc.toml
 create mode 100644 config/env/20240224-ls-square.toml

diff --git a/config/env/20240224-ls-4season.toml b/config/env/20240224-ls-4season.toml
new file mode 100644
index 00000000..e1e63773
--- /dev/null
+++ b/config/env/20240224-ls-4season.toml
@@ -0,0 +1,40 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 30, 0.01, 60]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [360.0, 180.0], [48.0, 36.0]],
+   ["switching",
+       1000,
+       ["gaussian", [360.0, 180.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 180.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 90.0], [48.0, 36.0]],
+   ],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 16
+sensor_length = 120.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file
diff --git a/config/env/20240224-ls-lvc.toml b/config/env/20240224-ls-lvc.toml
new file mode 100644
index 00000000..086433fd
--- /dev/null
+++ b/config/env/20240224-ls-lvc.toml
@@ -0,0 +1,29 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 50
+food_num_fn = ["logistic", 20, 0.01, 50]
+food_loc_fn = ["gaussian", [240.0, 180.0], [80.0, 60.0]]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 24
+sensor_length = 200.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file
diff --git a/config/env/20240224-ls-square.toml b/config/env/20240224-ls-square.toml
new file mode 100644
index 00000000..18683bfe
--- /dev/null
+++ b/config/env/20240224-ls-square.toml
@@ -0,0 +1,29 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 50
+food_num_fn = ["logistic", 20, 0.01, 50]
+food_loc_fn = "gaussian"
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 24
+sensor_length = 200.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 120.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From a87f397d06190ded2f4c1ddeae4ccae7b4def42f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 24 Feb 2024 15:23:01 +0900
Subject: [PATCH 282/337] Fix ls 4season

---
 config/env/20240224-ls-4season.toml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/config/env/20240224-ls-4season.toml b/config/env/20240224-ls-4season.toml
index e1e63773..de33c06b 100644
--- a/config/env/20240224-ls-4season.toml
+++ b/config/env/20240224-ls-4season.toml
@@ -19,8 +19,8 @@ xlim = [0.0, 480.0]
 ylim = [0.0, 360.0]
 env_shape = "square"
 neighbor_stddev = 100.0
-n_agent_sensors = 16
-sensor_length = 120.0
+n_agent_sensors = 24
+sensor_length = 200.0
 sensor_range = "wide"
 agent_radius = 10.0
 food_radius = 4.0

From 1a4594a7d9b12b34d1059ae6cb375d4ccfd594e6 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 24 Feb 2024 15:40:12 +0900
Subject: [PATCH 283/337] energy_cap=400 for ls envs

---
 config/env/20240224-ls-4season.toml | 2 +-
 config/env/20240224-ls-lvc.toml     | 2 +-
 config/env/20240224-ls-square.toml  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/config/env/20240224-ls-4season.toml b/config/env/20240224-ls-4season.toml
index de33c06b..63b433a5 100644
--- a/config/env/20240224-ls-4season.toml
+++ b/config/env/20240224-ls-4season.toml
@@ -31,7 +31,7 @@ angular_damping = 0.6
 max_force = 80.0
 min_force = -20.0
 init_energy = 40.0
-energy_capacity = 120.0
+energy_capacity = 400.0
 force_energy_consumption = 2e-5
 energy_share_ratio = 0.4
 n_velocity_iter = 6
diff --git a/config/env/20240224-ls-lvc.toml b/config/env/20240224-ls-lvc.toml
index 086433fd..ca8b0c81 100644
--- a/config/env/20240224-ls-lvc.toml
+++ b/config/env/20240224-ls-lvc.toml
@@ -20,7 +20,7 @@ angular_damping = 0.6
 max_force = 80.0
 min_force = -20.0
 init_energy = 40.0
-energy_capacity = 120.0
+energy_capacity = 400.0
 force_energy_consumption = 2e-5
 energy_share_ratio = 0.4
 n_velocity_iter = 6
diff --git a/config/env/20240224-ls-square.toml b/config/env/20240224-ls-square.toml
index 18683bfe..0dd42676 100644
--- a/config/env/20240224-ls-square.toml
+++ b/config/env/20240224-ls-square.toml
@@ -20,7 +20,7 @@ angular_damping = 0.6
 max_force = 80.0
 min_force = -20.0
 init_energy = 40.0
-energy_capacity = 120.0
+energy_capacity = 400.0
 force_energy_consumption = 2e-5
 energy_share_ratio = 0.4
 n_velocity_iter = 6

From a5c6f788ed189d5e92f59728ab1c18b192ffd98a Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Sat, 24 Feb 2024 17:52:42 +0900
Subject: [PATCH 284/337] 4season fromlv

---
 config/env/20240224-ls-4season-fromlv.toml | 40 ++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 config/env/20240224-ls-4season-fromlv.toml

diff --git a/config/env/20240224-ls-4season-fromlv.toml b/config/env/20240224-ls-4season-fromlv.toml
new file mode 100644
index 00000000..eb259a3b
--- /dev/null
+++ b/config/env/20240224-ls-4season-fromlv.toml
@@ -0,0 +1,40 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [240.0, 180.0], [80.0, 60.0]],
+   ["switching",
+       1000,
+       ["gaussian", [360.0, 180.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 180.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 90.0], [48.0, 36.0]],
+   ],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 24
+sensor_length = 200.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 400.0
+force_energy_consumption = 2e-5
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 1f4639a01a6abd0e96ce282b6fc6276545315669 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Sun, 25 Feb 2024 12:10:45 +0900
Subject: [PATCH 285/337] Make fromlv not centered

---
 config/env/20240224-ls-4season-fromlv.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config/env/20240224-ls-4season-fromlv.toml b/config/env/20240224-ls-4season-fromlv.toml
index eb259a3b..2d67d4da 100644
--- a/config/env/20240224-ls-4season-fromlv.toml
+++ b/config/env/20240224-ls-4season-fromlv.toml
@@ -5,7 +5,7 @@ food_num_fn = ["logistic", 20, 0.01, 60]
 food_loc_fn = [
    "scheduled",
    1024000,
-   ["gaussian", [240.0, 180.0], [80.0, 60.0]],
+   ["gaussian", [360.0, 180.0], [80.0, 60.0]],
    ["switching",
        1000,
        ["gaussian", [360.0, 180.0], [48.0, 36.0]],

From 9e63b339d405d4b02836c2961017896b0df5cad7 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Sun, 25 Feb 2024 12:12:11 +0900
Subject: [PATCH 286/337] Set default basic_energy_consumption for ls envs

---
 config/env/20240224-ls-4season-fromlv.toml | 1 +
 config/env/20240224-ls-4season.toml        | 1 +
 config/env/20240224-ls-lvc.toml            | 1 +
 config/env/20240224-ls-square.toml         | 1 +
 4 files changed, 4 insertions(+)

diff --git a/config/env/20240224-ls-4season-fromlv.toml b/config/env/20240224-ls-4season-fromlv.toml
index 2d67d4da..4ca286ba 100644
--- a/config/env/20240224-ls-4season-fromlv.toml
+++ b/config/env/20240224-ls-4season-fromlv.toml
@@ -33,6 +33,7 @@ min_force = -20.0
 init_energy = 40.0
 energy_capacity = 400.0
 force_energy_consumption = 2e-5
+basic_energy_consumption = 2e-4
 energy_share_ratio = 0.4
 n_velocity_iter = 6
 n_position_iter = 2
diff --git a/config/env/20240224-ls-4season.toml b/config/env/20240224-ls-4season.toml
index 63b433a5..548b7148 100644
--- a/config/env/20240224-ls-4season.toml
+++ b/config/env/20240224-ls-4season.toml
@@ -33,6 +33,7 @@ min_force = -20.0
 init_energy = 40.0
 energy_capacity = 400.0
 force_energy_consumption = 2e-5
+basic_energy_consumption = 2e-4
 energy_share_ratio = 0.4
 n_velocity_iter = 6
 n_position_iter = 2
diff --git a/config/env/20240224-ls-lvc.toml b/config/env/20240224-ls-lvc.toml
index ca8b0c81..1c997819 100644
--- a/config/env/20240224-ls-lvc.toml
+++ b/config/env/20240224-ls-lvc.toml
@@ -22,6 +22,7 @@ min_force = -20.0
 init_energy = 40.0
 energy_capacity = 400.0
 force_energy_consumption = 2e-5
+basic_energy_consumption = 2e-4
 energy_share_ratio = 0.4
 n_velocity_iter = 6
 n_position_iter = 2
diff --git a/config/env/20240224-ls-square.toml b/config/env/20240224-ls-square.toml
index 0dd42676..9009fdeb 100644
--- a/config/env/20240224-ls-square.toml
+++ b/config/env/20240224-ls-square.toml
@@ -22,6 +22,7 @@ min_force = -20.0
 init_energy = 40.0
 energy_capacity = 400.0
 force_energy_consumption = 2e-5
+basic_energy_consumption = 2e-4
 energy_share_ratio = 0.4
 n_velocity_iter = 6
 n_position_iter = 2

From 0d02ca25e8a3d1b2a3d995ca3f3a4787a975a1c0 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sun, 25 Feb 2024 14:33:35 +0900
Subject: [PATCH 287/337] lvc -> lv

---
 config/env/{20240224-ls-lvc.toml => 20240224-ls-lv.toml} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename config/env/{20240224-ls-lvc.toml => 20240224-ls-lv.toml} (100%)

diff --git a/config/env/20240224-ls-lvc.toml b/config/env/20240224-ls-lv.toml
similarity index 100%
rename from config/env/20240224-ls-lvc.toml
rename to config/env/20240224-ls-lv.toml

From 95643d06c12e461a059c44d3f738dc07e8cf3132 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sun, 25 Feb 2024 14:37:22 +0900
Subject: [PATCH 288/337] Not centered

---
 config/env/20240224-ls-lv.toml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/config/env/20240224-ls-lv.toml b/config/env/20240224-ls-lv.toml
index 1c997819..6c8865a6 100644
--- a/config/env/20240224-ls-lv.toml
+++ b/config/env/20240224-ls-lv.toml
@@ -1,8 +1,8 @@
 n_initial_agents = 50
 n_max_agents = 150
-n_max_foods = 50
-food_num_fn = ["logistic", 20, 0.01, 50]
-food_loc_fn = ["gaussian", [240.0, 180.0], [80.0, 60.0]]
+n_max_foods = 60
+food_num_fn = ["logistic", 20, 0.01, 60]
+food_loc_fn = ["gaussian", [360.0, 270.0], [80.0, 60.0]]
 agent_loc_fn = "uniform"
 xlim = [0.0, 480.0]
 ylim = [0.0, 360.0]

From 583415f98e53effbe5f29526a15e1aa3f15bb0a1 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sun, 25 Feb 2024 17:20:27 +0900
Subject: [PATCH 289/337] 5season

---
 config/env/20240225-ls-5season.toml | 42 +++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 config/env/20240225-ls-5season.toml

diff --git a/config/env/20240225-ls-5season.toml b/config/env/20240225-ls-5season.toml
new file mode 100644
index 00000000..342ad2a3
--- /dev/null
+++ b/config/env/20240225-ls-5season.toml
@@ -0,0 +1,42 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 30, 0.01, 60]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+   ["switching",
+       1000,
+       ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 210.0], [48.0, 36.0]],
+       ["gaussian", [180.0, 90.0], [48.0, 36.0]],
+       ["gaussian", [300.0, 90.0], [48.0, 36.0]],
+       ["gaussian", [360.0, 210.0], [48.0, 36.0]],
+   ],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 24
+sensor_length = 200.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 400.0
+force_energy_consumption = 2e-5
+basic_energy_consumption = 2e-4
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 17656ac55ae360362b4d811184a212d1e94ce244 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sun, 25 Feb 2024 20:53:13 +0900
Subject: [PATCH 290/337] Tweak on plotting

---
 scripts/plot_bd_models.py | 2 ++
 src/emevo/plotting.py     | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/scripts/plot_bd_models.py b/scripts/plot_bd_models.py
index 6d4fb1f8..2d569828 100644
--- a/scripts/plot_bd_models.py
+++ b/scripts/plot_bd_models.py
@@ -22,6 +22,7 @@ def plot_bd_models(
     config: Path = Path("config/bd/20230530-a035-e020.toml"),
     age_max: int = 200000,
     energy_max: float = 40,
+    hazard_max: float = 2e-4,
     survivorship_energy: float = 10.0,
     n_discr: int = 100,
     yes: bool = typer.Option(False, help="Skip all yes/no prompts"),
@@ -63,6 +64,7 @@ def plot_bd_models(
             hazard_fn=hazard_model,
             age_max=age_max,
             energy_max=energy_max,
+            hazard_max=hazard_max,
             n_discr=n_discr,
             method="hazard",
             shown_params=None if noparam else bd_config.hazard_params,
diff --git a/src/emevo/plotting.py b/src/emevo/plotting.py
index 94cbf4f8..788eb462 100644
--- a/src/emevo/plotting.py
+++ b/src/emevo/plotting.py
@@ -158,6 +158,7 @@ def vis_hazard(
     hazard_fn: bd.HazardFunction,
     age_max: int = 10000,
     energy_max: float = 16,
+    hazard_max: float = 2e-4,
     n_discr: int = 101,
     method: Literal["hazard", "cumulative hazard", "survival"] = "hazard",
     initial: bool = True,
@@ -191,6 +192,7 @@ def vis_hazard(
             ax.set_zlim((0.0, 1.0))
         else:
             ax.set_zscale("log")  # type: ignore
+            ax.set_zlim((1e-6, hazard_max))
             ax.zaxis.set_major_locator(ticker.LogLocator(base=100, numticks=10))
             ax.zaxis.set_major_formatter(
                 ticker.FuncFormatter(lambda x, _: f"{x:.0e}".replace("e-0", "e-"))

From 88609356cf84949e2a34d2ff07dc61eedd10ff90 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sun, 25 Feb 2024 20:53:24 +0900
Subject: [PATCH 291/337] 6season

---
 config/env/20240225-ls-6season.toml | 42 +++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 config/env/20240225-ls-6season.toml

diff --git a/config/env/20240225-ls-6season.toml b/config/env/20240225-ls-6season.toml
new file mode 100644
index 00000000..ce8681c8
--- /dev/null
+++ b/config/env/20240225-ls-6season.toml
@@ -0,0 +1,42 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 30, 0.01, 60]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["switching",
+       1000,
+       ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 90.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 90.0], [48.0, 36.0]],
+       ["gaussian", [360.0, 90.0], [48.0, 36.0]],
+   ],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 24
+sensor_length = 200.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 400.0
+force_energy_consumption = 2e-5
+basic_energy_consumption = 2e-4
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 2744bcba0ff8a75f1a8dfae99fa80450601b4276 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Mon, 26 Feb 2024 02:16:25 +0900
Subject: [PATCH 292/337] 6season2

---
 config/env/20240226-ls-6season2.toml | 42 ++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 config/env/20240226-ls-6season2.toml

diff --git a/config/env/20240226-ls-6season2.toml b/config/env/20240226-ls-6season2.toml
new file mode 100644
index 00000000..34b9659a
--- /dev/null
+++ b/config/env/20240226-ls-6season2.toml
@@ -0,0 +1,42 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 30, 0.01, 60]
+food_loc_fn = [
+   "scheduled",
+   1024000,
+   ["gaussian", [360.0, 180.0], [48.0, 36.0]],
+   ["switching",
+       1000,
+       ["gaussian", [360.0, 180.0], [48.0, 36.0]],
+       ["gaussian", [300.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [180.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 180.0], [48.0, 36.0]],
+       ["gaussian", [180.0, 90.0], [48.0, 36.0]],
+       ["gaussian", [300.0, 90.0], [48.0, 36.0]],
+   ],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 24
+sensor_length = 200.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 400.0
+force_energy_consumption = 2e-5
+basic_energy_consumption = 2e-4
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 5ca9126954c98b36177a057989b7436d41165e8d Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 26 Feb 2024 11:54:15 +0900
Subject: [PATCH 293/337] 6s/4s nop

---
 config/env/20240226-4s-nop.toml | 35 +++++++++++++++++++++++++++++++
 config/env/20240226-6s-nop.toml | 37 +++++++++++++++++++++++++++++++++
 2 files changed, 72 insertions(+)
 create mode 100644 config/env/20240226-4s-nop.toml
 create mode 100644 config/env/20240226-6s-nop.toml

diff --git a/config/env/20240226-4s-nop.toml b/config/env/20240226-4s-nop.toml
new file mode 100644
index 00000000..7f6e9b43
--- /dev/null
+++ b/config/env/20240226-4s-nop.toml
@@ -0,0 +1,35 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 30, 0.01, 60]
+food_loc_fn = ["switching",
+    1000,
+    ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+    ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+    ["gaussian", [120.0, 90.0], [48.0, 36.0]],
+    ["gaussian", [360.0, 90.0], [48.0, 36.0]],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 24
+sensor_length = 200.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 400.0
+force_energy_consumption = 2e-5
+basic_energy_consumption = 2e-4
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file
diff --git a/config/env/20240226-6s-nop.toml b/config/env/20240226-6s-nop.toml
new file mode 100644
index 00000000..0d59c796
--- /dev/null
+++ b/config/env/20240226-6s-nop.toml
@@ -0,0 +1,37 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 30, 0.01, 60]
+food_loc_fn = ["switching",
+    1000,
+    ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+    ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+    ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+    ["gaussian", [120.0, 90.0], [48.0, 36.0]],
+    ["gaussian", [240.0, 90.0], [48.0, 36.0]],
+    ["gaussian", [360.0, 90.0], [48.0, 36.0]],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 24
+sensor_length = 200.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 400.0
+force_energy_consumption = 2e-5
+basic_energy_consumption = 2e-4
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 5459fe92cf17808d356823bd536d2a0907326d08 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 26 Feb 2024 11:57:54 +0900
Subject: [PATCH 294/337] 6s-lvp

---
 ...40226-4s-nop.toml => 20240226-6s-lvp.toml} | 19 +++++++---
 config/env/20240226-6s-nop.toml               | 37 -------------------
 2 files changed, 13 insertions(+), 43 deletions(-)
 rename config/env/{20240226-4s-nop.toml => 20240226-6s-lvp.toml} (58%)
 delete mode 100644 config/env/20240226-6s-nop.toml

diff --git a/config/env/20240226-4s-nop.toml b/config/env/20240226-6s-lvp.toml
similarity index 58%
rename from config/env/20240226-4s-nop.toml
rename to config/env/20240226-6s-lvp.toml
index 7f6e9b43..5d7d3df4 100644
--- a/config/env/20240226-4s-nop.toml
+++ b/config/env/20240226-6s-lvp.toml
@@ -2,12 +2,19 @@ n_initial_agents = 50
 n_max_agents = 150
 n_max_foods = 60
 food_num_fn = ["logistic", 30, 0.01, 60]
-food_loc_fn = ["switching",
-    1000,
-    ["gaussian", [360.0, 270.0], [48.0, 36.0]],
-    ["gaussian", [120.0, 270.0], [48.0, 36.0]],
-    ["gaussian", [120.0, 90.0], [48.0, 36.0]],
-    ["gaussian", [360.0, 90.0], [48.0, 36.0]],
+food_loc_fn = [
+   "scheduled",
+   102400,
+   ["gaussian", [360.0, 270.0], [80.0, 60.0]],
+   ["switching",
+       1000,
+       ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 90.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 90.0], [48.0, 36.0]],
+       ["gaussian", [360.0, 90.0], [48.0, 36.0]],
+   ],
 ]
 agent_loc_fn = "uniform"
 xlim = [0.0, 480.0]
diff --git a/config/env/20240226-6s-nop.toml b/config/env/20240226-6s-nop.toml
deleted file mode 100644
index 0d59c796..00000000
--- a/config/env/20240226-6s-nop.toml
+++ /dev/null
@@ -1,37 +0,0 @@
-n_initial_agents = 50
-n_max_agents = 150
-n_max_foods = 60
-food_num_fn = ["logistic", 30, 0.01, 60]
-food_loc_fn = ["switching",
-    1000,
-    ["gaussian", [360.0, 270.0], [48.0, 36.0]],
-    ["gaussian", [240.0, 270.0], [48.0, 36.0]],
-    ["gaussian", [120.0, 270.0], [48.0, 36.0]],
-    ["gaussian", [120.0, 90.0], [48.0, 36.0]],
-    ["gaussian", [240.0, 90.0], [48.0, 36.0]],
-    ["gaussian", [360.0, 90.0], [48.0, 36.0]],
-]
-agent_loc_fn = "uniform"
-xlim = [0.0, 480.0]
-ylim = [0.0, 360.0]
-env_shape = "square"
-neighbor_stddev = 100.0
-n_agent_sensors = 24
-sensor_length = 200.0
-sensor_range = "wide"
-agent_radius = 10.0
-food_radius = 4.0
-dt = 0.1
-linear_damping = 0.8
-angular_damping = 0.6
-max_force = 80.0
-min_force = -20.0
-init_energy = 40.0
-energy_capacity = 400.0
-force_energy_consumption = 2e-5
-basic_energy_consumption = 2e-4
-energy_share_ratio = 0.4
-n_velocity_iter = 6
-n_position_iter = 2
-n_physics_iter = 5
-max_place_attempts = 10
\ No newline at end of file

From 6f4280b161d5f1c76f331421d935993a5718437c Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 26 Feb 2024 13:03:20 +0900
Subject: [PATCH 295/337] 6s lvp

---
 config/env/20240226-6s-lvp.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config/env/20240226-6s-lvp.toml b/config/env/20240226-6s-lvp.toml
index 5d7d3df4..f73df946 100644
--- a/config/env/20240226-6s-lvp.toml
+++ b/config/env/20240226-6s-lvp.toml
@@ -4,7 +4,7 @@ n_max_foods = 60
 food_num_fn = ["logistic", 30, 0.01, 60]
 food_loc_fn = [
    "scheduled",
-   102400,
+   1024000,
    ["gaussian", [360.0, 270.0], [80.0, 60.0]],
    ["switching",
        1000,

From 6e43a9560a2e401d2909b3f5422171de07ff52eb Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 26 Feb 2024 13:04:20 +0900
Subject: [PATCH 296/337] 6s lvp more compact

---
 config/env/20240226-6s-lvp.toml | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/config/env/20240226-6s-lvp.toml b/config/env/20240226-6s-lvp.toml
index f73df946..97108b98 100644
--- a/config/env/20240226-6s-lvp.toml
+++ b/config/env/20240226-6s-lvp.toml
@@ -8,12 +8,12 @@ food_loc_fn = [
    ["gaussian", [360.0, 270.0], [80.0, 60.0]],
    ["switching",
        1000,
-       ["gaussian", [360.0, 270.0], [48.0, 36.0]],
-       ["gaussian", [240.0, 270.0], [48.0, 36.0]],
-       ["gaussian", [120.0, 270.0], [48.0, 36.0]],
-       ["gaussian", [120.0, 90.0], [48.0, 36.0]],
-       ["gaussian", [240.0, 90.0], [48.0, 36.0]],
-       ["gaussian", [360.0, 90.0], [48.0, 36.0]],
+       ["gaussian", [360.0, 240.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 240.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 240.0], [48.0, 36.0]],
+       ["gaussian", [120.0, 120.0], [48.0, 36.0]],
+       ["gaussian", [240.0, 120.0], [48.0, 36.0]],
+       ["gaussian", [360.0, 120.0], [48.0, 36.0]],
    ],
 ]
 agent_loc_fn = "uniform"

From 672fed987384856f0da4d39f36bca511dca397d5 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 26 Feb 2024 13:06:50 +0900
Subject: [PATCH 297/337] Tweak on 6s3

---
 config/env/20240226-6s-lvp.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config/env/20240226-6s-lvp.toml b/config/env/20240226-6s-lvp.toml
index 97108b98..8ada3b3e 100644
--- a/config/env/20240226-6s-lvp.toml
+++ b/config/env/20240226-6s-lvp.toml
@@ -5,7 +5,7 @@ food_num_fn = ["logistic", 30, 0.01, 60]
 food_loc_fn = [
    "scheduled",
    1024000,
-   ["gaussian", [360.0, 270.0], [80.0, 60.0]],
+   ["gaussian", [360.0, 240.0], [80.0, 60.0]],
    ["switching",
        1000,
        ["gaussian", [360.0, 240.0], [48.0, 36.0]],

From aa10b619f61f3cb09d43292ec417bacb159d4a12 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 26 Feb 2024 13:07:09 +0900
Subject: [PATCH 298/337] tweak on 6s3

---
 config/env/20240226-6s-lvp.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config/env/20240226-6s-lvp.toml b/config/env/20240226-6s-lvp.toml
index 8ada3b3e..cb104809 100644
--- a/config/env/20240226-6s-lvp.toml
+++ b/config/env/20240226-6s-lvp.toml
@@ -4,7 +4,7 @@ n_max_foods = 60
 food_num_fn = ["logistic", 30, 0.01, 60]
 food_loc_fn = [
    "scheduled",
-   1024000,
+   102400,
    ["gaussian", [360.0, 240.0], [80.0, 60.0]],
    ["switching",
        1000,

From 796b2c7a57f6753418f1c238b0b8d79bc4d7fb03 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Mon, 26 Feb 2024 14:03:02 +0900
Subject: [PATCH 299/337] More preparation

---
 config/env/20240226-6s-lvp.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config/env/20240226-6s-lvp.toml b/config/env/20240226-6s-lvp.toml
index cb104809..8ada3b3e 100644
--- a/config/env/20240226-6s-lvp.toml
+++ b/config/env/20240226-6s-lvp.toml
@@ -4,7 +4,7 @@ n_max_foods = 60
 food_num_fn = ["logistic", 30, 0.01, 60]
 food_loc_fn = [
    "scheduled",
-   102400,
+   1024000,
    ["gaussian", [360.0, 240.0], [80.0, 60.0]],
    ["switching",
        1000,

From aa254e2afe1383beecf7e8119e8c5a602517a50b Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kanagawa@oist.jp>
Date: Tue, 27 Feb 2024 01:59:05 +0900
Subject: [PATCH 300/337] ls-season

---
 config/env/20240227-ls-season.toml | 35 ++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 config/env/20240227-ls-season.toml

diff --git a/config/env/20240227-ls-season.toml b/config/env/20240227-ls-season.toml
new file mode 100644
index 00000000..115494b6
--- /dev/null
+++ b/config/env/20240227-ls-season.toml
@@ -0,0 +1,35 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 60
+food_num_fn = ["logistic", 30, 0.01, 60]
+food_loc_fn = ["switching",
+   1000,
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+   ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+   ["gaussian", [240.0, 270.0], [48.0, 36.0]],
+]
+agent_loc_fn = "uniform"
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 24
+sensor_length = 200.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 400.0
+force_energy_consumption = 2e-5
+basic_energy_consumption = 2e-4
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 2c9b381bc50538e600fe882dcceb69f413afd4d6 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 27 Feb 2024 21:50:03 +0900
Subject: [PATCH 301/337] Tweak on plotting

---
 scripts/plot_bd_models.py | 54 ++++++++++++++++++++++++++++++++-------
 src/emevo/plotting.py     | 13 ++++++++--
 2 files changed, 56 insertions(+), 11 deletions(-)

diff --git a/scripts/plot_bd_models.py b/scripts/plot_bd_models.py
index 2d569828..4cc0095d 100644
--- a/scripts/plot_bd_models.py
+++ b/scripts/plot_bd_models.py
@@ -1,9 +1,11 @@
 import importlib
 from pathlib import Path
+from typing import cast
 
 import matplotlib as mpl
 import typer
 from matplotlib import pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
 from serde import toml
 
 from emevo.exp_utils import BDConfig
@@ -34,8 +36,12 @@ def plot_bd_models(
     nolifespan: bool = typer.Option(False, help="Don't show lifespan"),
     simpletitle: bool = typer.Option(False, help="Make title simple"),
     birth2d: bool = typer.Option(False, help="Make 2D plot for birth rate"),
+    all2d: bool = typer.Option(
+        False,
+        help="Plot birth, lifetime, and n. children on the same fig",
+    ),
 ) -> None:
-    if importlib.util.find_spec("PySide6") is not None:
+    if importlib.util.find_spec("PySide6") is not None:  # type: ignore
         mpl.use("QtAgg")
     else:
         mpl.use("TkAgg")
@@ -60,7 +66,7 @@ def plot_bd_models(
             ax1.set_title(f"{type(hazard_model).__name__} Hazard function")  # type: ignore
             ax2.set_title(f"{type(hazard_model).__name__} Survival function")  # type: ignore
         vis_hazard(
-            ax1,
+            cast(Axes3D, ax1),
             hazard_fn=hazard_model,
             age_max=age_max,
             energy_max=energy_max,
@@ -70,7 +76,7 @@ def plot_bd_models(
             shown_params=None if noparam else bd_config.hazard_params,
         )
         vis_hazard(
-            ax2,
+            cast(Axes3D, ax2),
             hazard_fn=hazard_model,
             age_max=age_max,
             energy_max=energy_max,
@@ -80,15 +86,15 @@ def plot_bd_models(
         plt.show()
 
     if yes or typer.confirm("Plot birth model?"):
-        fig = plt.figure(figsize=(6, 4))
+        fig = plt.figure(figsize=(5, 5))
         if birth2d:
             ax = fig.add_subplot(111)
         else:
             ax = fig.add_subplot(111, projection="3d")
         if simpletitle:
-            ax.set_title("Birth function")  # type: ignore
+            ax.set_title("Birth function", fontsize=14)
         else:
-            ax.set_title(f"{type(birth_model).__name__} Birth function")  # type: ignore
+            ax.set_title(f"{type(birth_model).__name__} Birth function", fontsize=14)
         if birth2d:
             vis_birth_2d(
                 ax,
@@ -98,7 +104,7 @@ def plot_bd_models(
             )
         else:
             vis_birth(
-                ax,
+                cast(Axes3D, ax),
                 birth_fn=birth_model,
                 age_max=age_max,
                 energy_max=energy_max,
@@ -134,7 +140,7 @@ def plot_bd_models(
         else:
             name = f"{type(hazard_model).__name__} & {type(birth_model).__name__} "
         if ax1 is not None:
-            ax1.set_title(f"{name}Expected Lifetime")  # type: ignore
+            ax1.set_title(f"{name}Expected Lifetime", fontsize=14)
             vis_lifetime(
                 ax1,
                 hazard_fn=hazard_model,
@@ -148,7 +154,7 @@ def plot_bd_models(
                 }
                 show_params_text(ax1, params, columns=2)
 
-        ax2.set_title(f"{name}Expected Num. of children")  # type: ignore
+        ax2.set_title(f"{name}Expected Num. of children", fontsize=14)
         vis_expected_n_children(
             ax2,
             birth_fn=birth_model,
@@ -158,6 +164,36 @@ def plot_bd_models(
         )
         plt.show()
 
+    if all2d and (yes or typer.confirm("Plot birth and n.children on the same fig?")):
+        fig = plt.figure(figsize=(15, 5))
+        fig.tight_layout()
+        ax1 = fig.add_subplot(131)
+        ax2 = fig.add_subplot(132)
+        ax3 = fig.add_subplot(133)
+        ax1.set_title("Birth function", fontsize=14)
+        vis_birth_2d(
+            ax1,
+            birth_fn=birth_model,
+            energy_max=energy_max,
+            initial=True,
+        )
+        ax2.set_title("Expected Lifetime", fontsize=14)
+        vis_lifetime(
+            ax2,
+            hazard_fn=hazard_model,
+            energy_max=energy_max,
+            n_discr=n_discr,
+        )
+        ax3.set_title("Expected Num. of children", fontsize=14)
+        vis_expected_n_children(
+            ax3,
+            birth_fn=birth_model,
+            hazard_fn=hazard_model,
+            energy_max=energy_max,
+            n_discr=n_discr,
+        )
+        plt.show()
+
 
 if __name__ == "__main__":
     typer.run(plot_bd_models)
diff --git a/src/emevo/plotting.py b/src/emevo/plotting.py
index 788eb462..f011a1d3 100644
--- a/src/emevo/plotting.py
+++ b/src/emevo/plotting.py
@@ -80,6 +80,15 @@ def vis_birth_2d(
     return cast(Line2D, lines[0])
 
 
+def _km_formatter(x: float, _) -> str:
+    if x < 1000:
+        return str(x)
+    elif x < 1000000:
+        return f"{int(x) // 1000}K"
+    else:
+        return f"{int(x) // 1000000}M"
+
+
 def vis_lifetime(
     ax: Axes,
     hazard_fn: bd.HazardFunction,
@@ -99,13 +108,13 @@ def vis_lifetime(
     if initial:
         ax.grid(True, which="major")
         ax.set_xlabel("Energy", fontsize=12)
-        ax.yaxis.set_major_formatter("{x:.0e}")
+        ax.yaxis.set_major_formatter(ticker.FuncFormatter(_km_formatter))
         ax.set_ylabel("Expected Lifetime", fontsize=12)
     return cast(Line2D, lines[0])
 
 
 def vis_expected_n_children(
-    ax: Axes3D,
+    ax: Axes,
     hazard_fn: bd.HazardFunction,
     birth_fn: bd.BirthFunction,
     energy_max: float = 16,

From 0cd19f2c83a865512d252d3ec6a869885653b2dd Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 27 Feb 2024 21:50:13 +0900
Subject: [PATCH 302/337] ls poison

---
 config/env/20240227-ls-poison.toml | 40 ++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 config/env/20240227-ls-poison.toml

diff --git a/config/env/20240227-ls-poison.toml b/config/env/20240227-ls-poison.toml
new file mode 100644
index 00000000..61a47cfe
--- /dev/null
+++ b/config/env/20240227-ls-poison.toml
@@ -0,0 +1,40 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 80
+n_food_sources = 2
+food_num_fn = [
+    ["logistic", 20, 0.01, 60],
+    ["logistic", 10, 0.01, 20],
+]
+food_loc_fn = [
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["gaussian", [360.0, 90.0], [48.0, 36.0]],
+]
+food_color = [[254, 2, 162, 255], [2, 254, 162, 255]]
+food_energy_coef = [1.0, -0.1]
+agent_loc_fn = "uniform"
+observe_food_label = true
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 24
+sensor_length = 200.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 400.0
+force_energy_consumption = 2e-5
+basic_energy_consumption = 2e-4
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 16c77707e2b6d88c4782404074fb46412271ff8a Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 28 Feb 2024 01:56:37 +0900
Subject: [PATCH 303/337] new delayed sig in notebook

---
 notebooks/reward_fn.ipynb | 42 ++++++++++++++++++++++-----------------
 1 file changed, 24 insertions(+), 18 deletions(-)

diff --git a/notebooks/reward_fn.ipynb b/notebooks/reward_fn.ipynb
index 9bb70845..38a5e0ca 100644
--- a/notebooks/reward_fn.ipynb
+++ b/notebooks/reward_fn.ipynb
@@ -100,7 +100,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "04c0cf339f8b47ae9d6454dd93fc68b9",
+       "model_id": "822d21dfc1b042f1a1565c7f857a58a9",
        "version_major": 2,
        "version_minor": 0
       },
@@ -115,18 +115,18 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "404bc3cf71754f1598e3e067e555cc6d",
+       "model_id": "73e6f78e248a4b3b8a3cebdba65d255a",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -144,14 +144,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "id": "64594795-61ee-46f9-b8f0-35325a5e2f56",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "5f94de4e010c4f8bbb7b859ac3aa14c7",
+       "model_id": "8db90f4d55a34d10a0cbbbc505fe8285",
        "version_major": 2,
        "version_minor": 0
       },
@@ -159,25 +159,25 @@
        "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=1.0, min=-1.0, step=0.002…"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "6a67a65bfa694280b5691854f9aee028",
+       "model_id": "611215df35f44bd68e9750e19d1e3ad0",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAlgAAAJYCAYAAAC+ZpjcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABEtUlEQVR4nO3deVhV5f7//9cGmVRwRBRRBKwcUtQcQsU0UY6aqQ160tLsZMcpU0/H1K/zqWjSLDO1OqmntLTJLEfSHDiRM2WDnlTMIYXUAgVFhPX7wx/70w4whpv23vh8XBdXrnvf6+b93ksuX6219sJmWZYlAAAAGOPh7AIAAADKGwIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWUA40aNBADz74oLPLuKYlS5bIZrPp6NGjfzjXHfopKzabTTNmzCjWPhcuXNDDDz+s2rVry2azaezYsWVSG4CiI2ABLmz//v265557FBoaKl9fX9WtW1fdunXTvHnznF0aXMjTTz+tJUuWaMSIEXrrrbf0wAMPOLsk4LpnsyzLcnYRAPL74osv1KVLF9WvX19DhgxR7dq1dfz4cX355Zc6fPiwDh06ZJ+blZUlDw8PeXl5ObHia8vJyVF2drZ8fHxks9muObdBgwbq3LmzlixZ8ucU50JsNpumT59erLNYt956qypUqKCEhISyKwxAsVRwdgEACvbUU0+pSpUq2rVrl6pWrerwWmpqqsO2j4/Pn1hZyXh6esrT07NMv8eVK1eUm5srb2/vMv0+pZGRkaFKlSoZXTM1NVVNmjQxuiaA0uESIeCiDh8+rKZNm+YLV5JUq1Yth+2C7ln6+uuvddttt8nPz08hISF68skntXjx4nz3QTVo0EB33HGHtmzZotatW8vPz0/NmjXTli1bJEkffvihmjVrJl9fX91yyy3at29fvno2b96s6OhoVapUSVWrVlWfPn30/fffO8wp6B4sy7L05JNPKiQkRBUrVlSXLl307bffFun9OXr0qGw2m1544QXNnTtXERER8vHx0XfffSdJOnDggO655x5Vr15dvr6+at26tVavXm3f/9dff5Wnp6defvll+9iZM2fk4eGhGjVq6Lcn90eMGKHatWvbt7dv3657771X9evXl4+Pj+rVq6dx48bp4sWLDjU++OCDqly5sg4fPqyePXvK399fgwYNknT1rOO4ceMUGBgof39/3XnnnTpx4kSRes+zZcsW2Ww2JScna82aNbLZbPb3OO+1lStX6qmnnlJISIh8fX3VtWtXh7OfAMoGZ7AAFxUaGqrExER98803uvnmm4u178mTJ9WlSxfZbDZNmjRJlSpV0htvvFHoma5Dhw5p4MCB+vvf/677779fL7zwgnr37q2FCxdq8uTJGjlypCQpLi5O/fv318GDB+XhcfX/zz777DP16NFD4eHhmjFjhi5evKh58+apQ4cO2rt3rxo0aFBondOmTdOTTz6pnj17qmfPntq7d6+6d++uy5cvF7nXxYsX69KlS3rkkUfk4+Oj6tWr69tvv1WHDh1Ut25dTZw4UZUqVdLKlSvVt29fffDBB+rXr5+qVq2qm2++Wdu2bdOYMWMkSQkJCbLZbDp37py+++47NW3aVNLVQBUdHW3/nu+9954yMzM1YsQI1ahRQzt37tS8efN04sQJvffeew71XblyRbGxserYsaNeeOEFVaxYUZL08MMP6+2339bAgQPVvn17bd68Wb169Spy35LUuHFjvfXWWxo3bpxCQkL0j3/8Q5IUGBhoD7LPPPOMPDw89PjjjystLU3PPfecBg0apB07dhTrewEoJguAS9q4caPl6elpeXp6WlFRUdaECROsDRs2WJcvX843NzQ01BoyZIh9+9FHH7VsNpu1b98++9jZs2et6tWrW5Ks5ORkh30lWV988YV9bMOGDZYky8/Pz/rxxx/t44sWLbIkWZ9//rl9rEWLFlatWrWss2fP2se++uory8PDwxo8eLB9bPHixQ7fOzU11fL29rZ69epl5ebm2udNnjzZkuTQT0GSk5MtSVZAQICVmprq8FrXrl2tZs2aWZcuXbKP5ebmWu3bt7duuOEG+9ioUaOsoKAg+/b48eOtTp06WbVq1bIWLFhgf99sNpv10ksv2edlZmbmqycuLs6y2WwO79eQIUMsSdbEiRMd5iYlJVmSrJEjRzqMDxw40JJkTZ8+/Zq9/15oaKjVq1cvh7HPP//ckmQ1btzYysrKso+/9NJLliRr//79xfoeAIqHS4SAi+rWrZsSExN155136quvvtJzzz2n2NhY1a1b1+FSV0HWr1+vqKgotWjRwj5WvXp1++Wp32vSpImioqLs2+3atZMk3X777apfv36+8SNHjkiSTp06paSkJD344IOqXr26fV7z5s3VrVs3rV27ttAaP/vsM12+fFmPPvqow03vxX3EwN13363AwED79rlz57R582b1799f58+f15kzZ3TmzBmdPXtWsbGx+uGHH3Ty5ElJUnR0tFJSUnTw4EFJV89UderUSdHR0dq+fbukq2e1LMtyOIPl5+dn/3NGRobOnDmj9u3by7KsAi+hjhgxwmE7733JO3NW0t6LYujQoQ73pOX1kXcMAZQNAhbgwtq0aaMPP/xQv/zyi3bu3KlJkybp/Pnzuueee+z3GhXkxx9/VMOGDfONFzQmySFESVKVKlUkSfXq1Stw/JdffrF/H0m66aab8q3ZuHFjnTlzRhkZGYXWKEk33HCDw3hgYKCqVatW4D4FCQsLc9g+dOiQLMvS1KlTFRgY6PA1ffp0Sf/3IYG8sLF9+3ZlZGRo3759io6OVqdOnewBa/v27QoICFBkZKT9exw7dsweKitXrqzAwEDddtttkqS0tDSHeipUqKCQkJB8vXt4eCgiIsJhvKD3sbR+f2zz3tu8YwigbHAPFuAGvL291aZNG7Vp00Y33nijhg4dqvfee88eGEqrsE/3FTZuudDTXX57NkmScnNzJUmPP/64YmNjC9wnL2gGBwcrLCxM27ZtU4MGDWRZlqKiohQYGKjHHntMP/74o7Zv36727dvb7znLyclRt27ddO7cOT3xxBNq1KiRKlWqpJMnT+rBBx+0f/88Pj4+9n2dwR2OIVAeEbAAN9O6dWtJVy/PFSY0NLTAT4qZ/vRYaGioJNkvsf3WgQMHVLNmzUIfSZC37w8//KDw8HD7+M8//1yqsyt5a3l5eSkmJuYP50dHR2vbtm0KCwtTixYt5O/vr8jISFWpUkXr16/X3r17NXPmTPv8/fv363//+5+WLl2qwYMH28fj4+OLXGNoaKhyc3N1+PBhh7NWBb2PANwTlwgBF/X5558XeJYh7/6da11Oio2NVWJiopKSkuxj586d07Jly4zWWKdOHbVo0UJLly7Vr7/+ah//5ptvtHHjRvXs2bPQfWNiYuTl5aV58+Y59Dl37txS1VSrVi117txZixYtKjCE/vzzzw7b0dHROnr0qFasWGG/ZOjh4aH27dtrzpw5ys7Odrj/Ku+M0G9rtixLL730UpFr7NGjhyQ5PCJCKn3vAFwHZ7AAF/Xoo48qMzNT/fr1U6NGjXT58mV98cUXWrFihRo0aKChQ4cWuu+ECRP09ttvq1u3bnr00Uftj2moX7++zp0794dPUi+O559/Xj169FBUVJT+9re/2R/TUKVKlWs+jTwwMFCPP/644uLidMcdd6hnz57at2+f1q1bp5o1a5aqpvnz56tjx45q1qyZhg0bpvDwcKWkpCgxMVEnTpzQV199ZZ+bF54OHjyop59+2j7eqVMnrVu3Tj4+PmrTpo19vFGjRoqIiNDjjz+ukydPKiAgQB988EGxzrq1aNFC9913n1599VWlpaWpffv22rRpE8+nAsoRAhbgol544QW99957Wrt2rV577TVdvnxZ9evX18iRIzVlypQCH0Cap169evr88881ZswYPf300woMDNSoUaNUqVIljRkzRr6+vsbqjImJ0fr16zV9+nRNmzZNXl5euu222/Tss8/muwH995588kn5+vpq4cKF+vzzz9WuXTtt3Lix2M+D+r0mTZpo9+7dmjlzppYsWaKzZ8+qVq1aatmypaZNm+Yw96abblKtWrWUmpqqjh072sfzglfbtm0dnh/m5eWlTz75RGPGjFFcXJx8fX3Vr18/jR492uFG+D/y5ptvKjAwUMuWLdOqVat0++23a82aNfk+WADAPfG7CIHryNixY7Vo0SJduHChzH9tDQBcz7gHCyinfv9rW86ePau33npLHTt2JFwBQBnjEiFQTkVFRalz585q3LixUlJS9O9//1vp6emaOnWqs0tDEeTk5OS7If/3KleurMqVK/9JFQEoDgIWUE717NlT77//vl577TXZbDa1atVK//73v9WpUydnl4YiOH78+B/ewzZ9+vRrfpAAgPNwDxYAuKBLly4pISHhmnPCw8MdniEGwHUQsAAAAAzjJncAAADDuAeriHJzc/XTTz/J39/f6EMaAQAo7yzL0vnz5xUcHOzU3835ZyJgFdFPP/3EAwABACiF48ePKyQkxNll/CkIWEXk7+8v6epfjoCAACNrZmdna+PGjerevbu8vLyMrOls9OQe6Mn1lbd+JHpyF2XRU3p6uurVq2f/t/R6QMAqorzLggEBAUYDVsWKFRUQEFCufjDpyfXRk+srb/1I9OQuyrKn6+kWm+vjQigAAMCfiIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGOZyAWvbtm3q3bu3goODZbPZtGrVqj/cZ8uWLWrVqpV8fHzUsGFDLVmypNC5zzzzjGw2m8aOHWusZgAAgN9yuYCVkZGhyMhIzZ8/v0jzk5OT1atXL3Xp0kVJSUkaO3asHn74YW3YsCHf3F27dmnRokVq3ry56bIBAADsKji7gN/r0aOHevToUeT5CxcuVFhYmGbPni1Jaty4sRISEvTiiy8qNjbWPu/ChQsaNGiQXn/9dT355JPG6wYAAMjjcgGruBITExUTE+MwFhsbm+8S4KhRo9SrVy/FxMQUKWBlZWUpKyvLvp2eni5Jys7OVnZ2dukL///X+u1/ywN6cg/05PrKWz8SPbmLsuipPL0/ReX2Aev06dMKCgpyGAsKClJ6erouXrwoPz8/vfvuu9q7d6927dpV5HXj4uI0c+bMfOMbN25UxYoVS133b8XHxxtdzxXQk3ugJ9dX3vqR6MldmOwpMzPT2Fruwu0D1h85fvy4HnvsMcXHx8vX17fI+02aNEnjx4+3b6enp6tevXrq3r27AgICjNSWnZ2t+Ph4devWTV5eXkbWdDZ6cg/05PrKWz8SPbmLsugp7yrQ9cTtA1bt2rWVkpLiMJaSkqKAgAD5+flpz549Sk1NVatWreyv5+TkaNu2bXrllVeUlZUlT0/PfOv6+PjIx8cn37iXl5fxH6KyWNPZ6Mk90JPrK2/9SPTkLkz2VN7em6Jw+4AVFRWltWvXOozFx8crKipKktS1a1ft37/f4fWhQ4eqUaNGeuKJJwoMVwAAAKXhcgHrwoULOnTokH07OTlZSUlJql69uurXr69Jkybp5MmT+s9//iNJGj58uF555RVNmDBBDz30kDZv3qyVK1dqzZo1kiR/f3/dfPPNDt+jUqVKqlGjRr5xAAAAE1zuOVi7d+9Wy5Yt1bJlS0nS+PHj1bJlS02bNk2SdOrUKR07dsw+PywsTGvWrFF8fLwiIyM1e/ZsvfHGGw6PaAAAAPgzudwZrM6dO8uyrEJfL+gp7Z07d9a+ffuK/D22bNlSgsoAAACKxuXOYAEAALg7AhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwlwtY27ZtU+/evRUcHCybzaZVq1b94T5btmxRq1at5OPjo4YNG2rJkiUOr8fFxalNmzby9/dXrVq11LdvXx08eLBsGgAAANc9lwtYGRkZioyM1Pz584s0Pzk5Wb169VKXLl2UlJSksWPH6uGHH9aGDRvsc7Zu3apRo0bpyy+/VHx8vLKzs9W9e3dlZGSUVRsAAOA6VsHZBfxejx491KNHjyLPX7hwocLCwjR79mxJUuPGjZWQkKAXX3xRsbGxkqT169c77LNkyRLVqlVLe/bsUadOncwVDwAAIBcMWMWVmJiomJgYh7HY2FiNHTu20H3S0tIkSdWrVy90TlZWlrKysuzb6enpkqTs7GxlZ2eXouL/k7eOqfVcAT25B3pyfeWtH4me3EVZ9FSe3p+islmWZTm7iMLYbDZ99NFH6tu3b6FzbrzxRg0dOlSTJk2yj61du1a9evVSZmam/Pz8HObn5ubqzjvv1K+//qqEhIRC150xY4ZmzpyZb3z58uWqWLFi8ZsBAOA6lZmZqYEDByotLU0BAQHOLudP4fZnsIpr1KhR+uabb64ZriRp0qRJGj9+vH07PT1d9erVU/fu3Y395cjOzlZ8fLy6desmLy8vI2s6Gz25B3pyfeWtH4me3EVZ9JR3Feh64vYBq3bt2kpJSXEYS0lJUUBAQL6zV6NHj9ann36qbdu2KSQk5Jrr+vj4yMfHJ9+4l5eX8R+isljT2ejJPdCT6ytv/Uj05C5M9lTe3puicLlPERZXVFSUNm3a5DAWHx+vqKgo+7ZlWRo9erQ++ugjbd68WWFhYX92mQAA4DricgHrwoULSkpKUlJSkqSrj2FISkrSsWPHJF29dDd48GD7/OHDh+vIkSOaMGGCDhw4oFdffVUrV67UuHHj7HNGjRqlt99+W8uXL5e/v79Onz6t06dP6+LFi39qbwAA4PrgcgFr9+7datmypVq2bClJGj9+vFq2bKlp06ZJkk6dOmUPW5IUFhamNWvWKD4+XpGRkZo9e7beeOMN+yMaJGnBggVKS0tT586dVadOHfvXihUr/tzmAADAdcHl7sHq3LmzrvXBxt8/pT1vn3379hW6jwt/UBIAAJRDLncGCwAAwN0RsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYVOWCtXr1aP/30U1nWAgAAUC4UOWD169dPW7ZssW+Hh4dr9erVZVETAACAWytywPL399evv/5q3z569KguXLhQFjUBAAC4tQpFndi2bVs99dRTSklJUZUqVSRJa9eu1enTpwvdx2azady4caWvEgAAwI0UOWC9+uqrGjx4sP71r39Juhqeli9fruXLlxe6DwELAABcj4ocsBo2bKgvvvhCly5dUmpqqho0aKC5c+eqT58+ZVkfAACA2ylywMrj6+ur+vXra/r06br99tsVGhpaFnUBAAC4rWIHrDzTp0+3//nUqVNKTU1Vw4YNValSJSOFAQAAuKtSPWj0448/VqNGjRQSEqJWrVppx44dkqQzZ86oZcuWWrVqlYkaAQAA3EqJA9Ynn3yiu+66SzVr1tT06dNlWZb9tZo1a6pu3bpavHixkSIBAADcSYkD1qxZs9SpUyclJCRo1KhR+V6PiorSvn37SlUcAACAOypxwPrmm2/Uv3//Ql8PCgpSampqSZcHAABwWyUOWBUrVlRGRkahrx85ckQ1atQo6fIAAABuq8QBq0uXLlq6dKmuXLmS77XTp0/r9ddfV/fu3UtVHAAAgDsqccB66qmndOLECbVp00aLFi2SzWbThg0bNGXKFDVr1kyWZTk8ygEAAOB6UeKAddNNNykhIUE1atTQ1KlTZVmWnn/+eT399NNq1qyZtm/frgYNGhgsFQAAwD2U+EGjktS0aVN99tln+uWXX3To0CHl5uYqPDxcgYGBpuoDAABwO6UKWHmqVaumNm3amFgKAADA7ZXqSe7p6emaOXOm2rZtq6CgIAUFBalt27aaNWuW0tPTTdUIAADgVkocsH766Se1bNlSM2fO1IULF9ShQwd16NBBGRkZmjFjhlq1aqVTp06ZrBUAAMAtlPgS4RNPPKHTp0/r008/Vc+ePR1eW7dune69915NnDhRS5cuLXWRAAAA7qTEZ7DWr1+vsWPH5gtXktSjRw+NGTNGa9euLVVxAAAA7qjEASsjI0NBQUGFvl67du1rPukdAACgvCpxwGrSpIneeecdXb58Od9r2dnZeuedd9SkSZNSFQcAAOCOSnUP1oABA9S2bVuNHDlSN954oyTp4MGDWrhwob7++mutWLHCWKEAAADuosQB695771VGRoYmTpyo4cOHy2azSZIsy1KtWrX05ptv6p577jFWKAAAgLso1YNGH3zwQd1///3avXu3fvzxR0lSaGioWrdurQoVjDzDFAAAwO2UOgVVqFBBt956q2699VYT9QAAALi9Yt3kfurUKTVq1EhTp0695rwpU6aocePGSk1NLVVxAAAA7qhYAeull17SuXPn9MQTT1xz3hNPPKFz585p3rx5pSoOAADAHRUrYK1Zs0b33XefKleufM15/v7+GjhwoFavXl2q4gAAANxRsQLW4cOH1bx58yLNbdq0qQ4dOlSiogAAANxZsQKWp6dngQ8WLUh2drY8PEr8HFMAAAC3VawEFBERoYSEhCLN/e9//6uIiIgSFQUAAODOihWw+vXrp/fee0+JiYnXnPfll19q5cqV6tevX6mKAwAAcEfFCljjx49XSEiIunfvrmeffVYnT550eP3kyZN69tln1b17d4WEhGjcuHFGiwUAAHAHxQpY/v7++uyzzxQREaFJkyapfv36ql69ukJDQ1W9enXVr19fkyZNUlhYmOLj4xUQEFBWdQMAALisYj/JPTw8XHv27NH777+v1atX68CBA0pPT1dYWJgaNWqk3r1765577uFX5QAAgOtWiVKQp6enBgwYoAEDBpiuBwAAwO3xHAUAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgWJEf0zBr1qxiL26z2TR16tRi7wcAAODOihywZsyYkW/MZrNJkizLyjduWRYBCwAAXJeKfIkwNzfX4ev48eNq1qyZ7rvvPu3cuVNpaWlKS0vTjh079Ne//lWRkZE6fvx4WdYOAADgkkp8D9aoUaN0ww036O2331br1q3l7+8vf39/tWnTRsuWLVNERIRGjRpV7HW3bdum3r17Kzg4WDabTatWrfrDfbZs2aJWrVrJx8dHDRs21JIlS/LNmT9/vho0aCBfX1+1a9dOO3fuLHZtAAAARVHigLV582bdfvvthb7etWtXbdq0qdjrZmRkKDIyUvPnzy/S/OTkZPXq1UtdunRRUlKSxo4dq4cfflgbNmywz1mxYoXGjx+v6dOna+/evYqMjFRsbKxSU1OLXR8AAMAfKfFvZPb19VViYqJGjBhR4OtffPGFfH19i71ujx491KNHjyLPX7hwocLCwjR79mxJUuPGjZWQkKAXX3xRsbGxkqQ5c+Zo2LBhGjp0qH2fNWvW6M0339TEiROLXaMJlmXp8kVLOZc9dPmipdwruU6pw7Qr2fTkDujJ9ZW3fiR6chd5Pf3+/moUT4kD1qBBg/Tyyy+ratWqevTRRxURESFJOnz4sF5++WUtX75cY8aMMVZoYRITExUTE+MwFhsbq7Fjx0qSLl++rD179mjSpEn21z08PBQTE6PExMRC183KylJWVpZ9Oz09XZKUnZ2t7OzsUtd9+aKlKT3PSWqj7S+dK/V6roWe3AM9ub7y1o9ET+6ijW6/PVu2AJuR1Uz8u+luShywnn32WZ05c0avvPKK5s+fLw+Pq1cbc3NzZVmW7rvvPj377LPGCi3M6dOnFRQU5DAWFBSk9PR0Xbx4Ub/88otycnIKnHPgwIFC142Li9PMmTPzjW/cuFEVK1Ysdd05lz0ktSn1OgAAlIXNmzfL09vMWbnMzEwj67iTEgcsb29vvfXWW/rnP/+ptWvX6scff5QkhYaGqkePHoqMjDRWpDNMmjRJ48ePt2+np6erXr166t69uwICAkq9vmVZuv32bPu9bF5eXqVe0xVkZ9OTO6An11fe+pHoyV3k9RTb83Z5e3sbWTPvKtD1pEQBKzMzU/fff7/uvvtuDRo0SM2bNzddV5HVrl1bKSkpDmMpKSkKCAiQn5+fPD095enpWeCc2rVrF7quj4+PfHx88o17eXkZ+yGyBdjk6Z2rSgHe5egHk57cAT25vvLWj0RP7iKvJ29vcz2Vl/emOEr0KcKKFSvqs88+c4lTflFRUfk+rRgfH6+oqChJV8+03XLLLQ5zcnNztWnTJvscAAAAk0r8mIaOHTte8ybxkrpw4YKSkpKUlJQk6epjGJKSknTs2DFJVy/dDR482D5/+PDhOnLkiCZMmKADBw7o1Vdf1cqVKzVu3Dj7nPHjx+v111/X0qVL9f3332vEiBHKyMiwf6oQAADApBLfg/XKK68oNjZWU6ZM0fDhwxUSEmKkoN27d6tLly727bz7oIYMGaIlS5bo1KlT9rAlSWFhYVqzZo3GjRunl156SSEhIXrjjTfsj2iQpAEDBujnn3/WtGnTdPr0abVo0ULr16/Pd+M7AACACSUOWJGRkbpy5Yri4uIUFxenChUq5LtnyWazKS0trVjrdu7c+ZrP3ijoKe2dO3fWvn37rrnu6NGjNXr06GLVAgAAUBIlDlh33323/Zc9AwAA4P+UOGAVdCYJAAAApbjJHQAAAAUr8RmsPCdOnNC+ffuUlpam3Nz8T3z97Sf+AAAArgclDliXLl3SkCFD9MEHHyg3N1c2m81+c/pv780iYAEAgOtNiS8RTp48WR9++KGeeuopbdmyRZZlaenSpdq4caP9V+V89dVXJmsFAABwCyUOWO+//76GDh2qJ554Qk2bNpUk1a1bVzExMfr0009VtWpVzZ8/31ihAAAA7qLEASs1NVVt27aVJPn5+UmSMjIy7K/ffffd+vDDD0tZHgAAgPspccAKCgrS2bNnJV393YTVqlXTwYMH7a+np6fr0qVLpa8QAADAzZT4Jvd27dopISFBTzzxhCSpd+/eev7551WnTh3l5ubqxRdf1K233mqsUAAAAHdR4jNYY8aMUXh4uLKysiRJ//rXv1S1alU98MADGjJkiKpUqaKXX37ZWKEAAADuosRnsDp27KiOHTvat+vVq6fvv/9e+/fvl6enpxo1aqQKFUr9mC0AAAC3YzQBeXh4KDIy0uSSAAAAbqfEASs4OFjR0dH2L4IVAADAVSUOWH369FFCQoLef/99SVJAQIDat2+vTp06KTo6Wm3atJGXl5exQgEAANxFiQPWggULJEm//PKLtm/fru3btyshIUHTpk3TlStX5OPjo3bt2unzzz83ViwAAIA7KPU9WNWqVdOdd96pO++8U8ePH9e6des0Z84c/e9//9O2bdtM1AgAAOBWShWwvv/+e/vZq+3bt+v48eOqUqWKoqKiNHToUEVHR5uqEwAAwG2UOGAFBgbq3LlzqlWrlqKjo/WPf/zDfrO7zWYzWSMAAIBbKfGDRs+ePSubzaZGjRqpcePGaty4sW644QbCFQAAuO6V+AzWzz//rISEBG3fvl3r169XXFycJKlFixb2Rzd07NhRNWvWNFYsAACAOyhxwKpRo4b69OmjPn36SJIyMzOVmJio7du3a+XKlZo7d65sNpuuXLlirFgAAAB3YORJ7j/88IO2b9+ubdu2afv27UpOTpZ09T4tAACA602JA9Yrr7yibdu2KSEhQSkpKbIsS2FhYYqOjtbkyZMVHR2tG2+80WStAAAAbqHEAWvs2LG6+eabdffdd9vvuapTp47J2gAAANxSiQPW2bNnVaVKFZO1AAAAlAslfkzDb8PVqVOn9NVXXykjI8NIUQAAAO6sxAFLkj7++GM1atRIISEhatWqlXbs2CFJOnPmjFq2bKlVq1aZqBEAAMCtlDhgffLJJ7rrrrtUs2ZNTZ8+XZZl2V+rWbOm6tatq8WLFxspEgAAwJ2UOGDNmjVLnTp1UkJCgkaNGpXv9aioKO3bt69UxQEAALijEgesb775Rv379y/09aCgIKWmppZ0eQAAALdV4oBVsWLFa97UfuTIEdWoUaOkywMAALitEgesLl26aOnSpQX+KpzTp0/r9ddfV/fu3UtVHAAAgDsqccB66qmndOLECbVp00aLFi2SzWbThg0bNGXKFDVr1kyWZWn69OkmawUAAHALJQ5YN910kxISElSjRg1NnTpVlmXp+eef19NPP61mzZpp+/btatCggcFSAQAA3EOpftlz06ZN9dlnn+mXX37RoUOHlJubq/DwcPsvebYsSzabzUihAAAA7qJUDxrNU61aNbVp00bt2rVTYGCgLl++rNdee0033XSTieUBAADcSrHPYF2+fFmrV6/W4cOHVa1aNd1xxx0KDg6WJGVmZuqVV17R3Llzdfr0aUVERBgvGAAAwNUVK2D99NNP6ty5sw4fPmx/crufn59Wr14tb29vDRw4UCdPnlTbtm01b9483XXXXWVSNAAAgCsrVsD6f//v/yk5OVkTJkxQdHS0kpOTNWvWLD3yyCM6c+aMmjZtqrffflu33XZbWdULAADg8ooVsOLj4zV06FDFxcXZx2rXrq17771XvXr10scffywPDyO3dQEAALitYqWhlJQU3XrrrQ5jedsPPfQQ4QoAAEDFDFg5OTny9fV1GMvbrlKlirmqAAAA3FixP0V49OhR7d27176dlpYmSfrhhx9UtWrVfPNbtWpV8uoAAADcULED1tSpUzV16tR84yNHjnTYznvIaE5OTsmrAwAAcEPFCliLFy8uqzoAAADKjWIFrCFDhpRVHQAAAOUGH/sDAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwzCUD1vz589WgQQP5+vqqXbt22rlzZ6Fzs7OzNWvWLEVERMjX11eRkZFav369w5ycnBxNnTpVYWFh8vPzU0REhP71r3/JsqyybgUAAFyHXC5grVixQuPHj9f06dO1d+9eRUZGKjY2VqmpqQXOnzJlihYtWqR58+bpu+++0/Dhw9WvXz/t27fPPufZZ5/VggUL9Morr+j777/Xs88+q+eee07z5s37s9oCAADXEZcLWHPmzNGwYcM0dOhQNWnSRAsXLlTFihX15ptvFjj/rbfe0uTJk9WzZ0+Fh4drxIgR6tmzp2bPnm2f88UXX6hPnz7q1auXGjRooHvuuUfdu3e/5pkxAACAknKpgHX58mXt2bNHMTEx9jEPDw/FxMQoMTGxwH2ysrLk6+vrMObn56eEhAT7dvv27bVp0yb973//kyR99dVXSkhIUI8ePcqgCwAAcL2r4OwCfuvMmTPKyclRUFCQw3hQUJAOHDhQ4D6xsbGaM2eOOnXqpIiICG3atEkffvihcnJy7HMmTpyo9PR0NWrUSJ6ensrJydFTTz2lQYMGFVpLVlaWsrKy7Nvp6emSrt7zlZ2dXZo27fLWMbWeK6An90BPrq+89SPRk7soi57K0/tTVC4VsEripZde0rBhw9SoUSPZbDZFRERo6NChDpcUV65cqWXLlmn58uVq2rSpkpKSNHbsWAUHB2vIkCEFrhsXF6eZM2fmG9+4caMqVqxotIf4+Hij67kCenIP9OT6yls/Ej25C5M9ZWZmGlvLXdgsF/oo3eXLl1WxYkW9//776tu3r318yJAh+vXXX/Xxxx8Xuu+lS5d09uxZBQcHa+LEifr000/17bffSpLq1auniRMnatSoUfb5Tz75pN5+++1Cz4wVdAarXr16OnPmjAICAkrZ6VXZ2dmKj49Xt27d5OXlZWRNZ6Mn90BPrq+89SPRk7soi57S09NVs2ZNpaWlGfs31NW51Bksb29v3XLLLdq0aZM9YOXm5mrTpk0aPXr0Nff19fVV3bp1lZ2drQ8++ED9+/e3v5aZmSkPD8fbzTw9PZWbm1voej4+PvLx8ck37uXlZfyHqCzWdDZ6cg/05PrKWz8SPbkLkz2Vt/emKFwqYEnS+PHjNWTIELVu3Vpt27bV3LlzlZGRoaFDh0qSBg8erLp16youLk6StGPHDp08eVItWrTQyZMnNWPGDOXm5mrChAn2NXv37q2nnnpK9evXV9OmTbVv3z7NmTNHDz30kFN6BAAA5ZvLBawBAwbo559/1rRp03T69Gm1aNFC69evt9/4fuzYMYezUZcuXdKUKVN05MgRVa5cWT179tRbb72lqlWr2ufMmzdPU6dO1ciRI5Wamqrg4GD9/e9/17Rp0/7s9gAAwHXA5QKWJI0ePbrQS4Jbtmxx2L7tttv03XffXXM9f39/zZ07V3PnzjVUIQAAQOFc6jlYAAAA5QEBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYJhLBqz58+erQYMG8vX1Vbt27bRz585C52ZnZ2vWrFmKiIiQr6+vIiMjtX79+nzzTp48qfvvv181atSQn5+fmjVrpt27d5dlGwAA4DrlcgFrxYoVGj9+vKZPn669e/cqMjJSsbGxSk1NLXD+lClTtGjRIs2bN0/fffedhg8frn79+mnfvn32Ob/88os6dOggLy8vrVu3Tt99951mz56tatWq/VltAQCA64jLBaw5c+Zo2LBhGjp0qJo0aaKFCxeqYsWKevPNNwuc/9Zbb2ny5Mnq2bOnwsPDNWLECPXs2VOzZ8+2z3n22WdVr149LV68WG3btlVYWJi6d++uiIiIP6stAABwHXGpgHX58mXt2bNHMTEx9jEPDw/FxMQoMTGxwH2ysrLk6+vrMObn56eEhAT79urVq9W6dWvde++9qlWrllq2bKnXX3+9bJoAAADXvQrOLuC3zpw5o5ycHAUFBTmMBwUF6cCBAwXuExsbqzlz5qhTp06KiIjQpk2b9OGHHyonJ8c+58iRI1qwYIHGjx+vyZMna9euXRozZoy8vb01ZMiQAtfNyspSVlaWfTs9PV3S1Xu+srOzS9uqfa3f/rc8oCf3QE+ur7z1I9GTuyiLnsrT+1NUNsuyLGcXkeenn35S3bp19cUXXygqKso+PmHCBG3dulU7duzIt8/PP/+sYcOG6ZNPPpHNZlNERIRiYmL05ptv6uLFi5Ikb29vtW7dWl988YV9vzFjxmjXrl2FnhmbMWOGZs6cmW98+fLlqlixYmlbBQDgupGZmamBAwcqLS1NAQEBzi7nT+FSZ7Bq1qwpT09PpaSkOIynpKSodu3aBe4TGBioVatW6dKlSzp79qyCg4M1ceJEhYeH2+fUqVNHTZo0cdivcePG+uCDDwqtZdKkSRo/frx9Oz09XfXq1VP37t2N/eXIzs5WfHy8unXrJi8vLyNrOhs9uQd6cn3lrR+JntxFWfSUdxXoeuJSAcvb21u33HKLNm3apL59+0qScnNztWnTJo0ePfqa+/r6+qpu3brKzs7WBx98oP79+9tf69Chgw4ePOgw/3//+59CQ0MLXc/Hx0c+Pj75xr28vIz/EJXFms5GT+6BnlxfeetHoid3YbKn8vbeFIVLBSxJGj9+vIYMGaLWrVurbdu2mjt3rjIyMjR06FBJ0uDBg1W3bl3FxcVJknbs2KGTJ0+qRYsWOnnypGbMmKHc3FxNmDDBvua4cePUvn17Pf300+rfv7927typ1157Ta+99ppTegQAAOWbywWsAQMG6Oeff9a0adN0+vRptWjRQuvXr7ff+H7s2DF5ePzfhx8vXbqkKVOm6MiRI6pcubJ69uypt956S1WrVrXPadOmjT766CNNmjRJs2bNUlhYmObOnatBgwb92e0BAIDrgMsFLEkaPXp0oZcEt2zZ4rB922236bvvvvvDNe+44w7dcccdJsoDAAC4Jpd6DhYAAEB5QMACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADKvg7ALchWVZkqT09HRja2ZnZyszM1Pp6eny8vIytq4z0ZN7oCfXV976kejJXZRFT3n/dub9W3o9IGAV0fnz5yVJ9erVc3IlAAC4p/Pnz6tKlSrOLuNPYbOupzhZCrm5ufrpp5/k7+8vm81mZM309HTVq1dPx48fV0BAgJE1nY2e3AM9ub7y1o9ET+6iLHqyLEvnz59XcHCwPDyuj7uTOINVRB4eHgoJCSmTtQMCAsrND2YeenIP9OT6yls/Ej25C9M9XS9nrvJcHzESAADgT0TAAgAAMIyA5UQ+Pj6aPn26fHx8nF2KMfTkHujJ9ZW3fiR6chflsSdn4CZ3AAAAwziDBQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWE40f/58NWjQQL6+vmrXrp127tzp7JJKbMaMGbLZbA5fjRo1cnZZxbJt2zb17t1bwcHBstlsWrVqlcPrlmVp2rRpqlOnjvz8/BQTE6MffvjBOcUWwR/18+CDD+Y7Zn/5y1+cU2wRxcXFqU2bNvL391etWrXUt29fHTx40GHOpUuXNGrUKNWoUUOVK1fW3XffrZSUFCdV/MeK0lPnzp3zHavhw4c7qeJrW7BggZo3b25/SGVUVJTWrVtnf93djo/0xz250/EpzDPPPCObzaaxY8fax9zxWLkSApaTrFixQuPHj9f06dO1d+9eRUZGKjY2Vqmpqc4urcSaNm2qU6dO2b8SEhKcXVKxZGRkKDIyUvPnzy/w9eeee04vv/yyFi5cqB07dqhSpUqKjY3VpUuX/uRKi+aP+pGkv/zlLw7H7J133vkTKyy+rVu3atSoUfryyy8VHx+v7Oxsde/eXRkZGfY548aN0yeffKL33ntPW7du1U8//aS77rrLiVVfW1F6kqRhw4Y5HKvnnnvOSRVfW0hIiJ555hnt2bNHu3fv1u23364+ffro22+/leR+x0f6454k9zk+Bdm1a5cWLVqk5s2bO4y747FyKRacom3bttaoUaPs2zk5OVZwcLAVFxfnxKpKbvr06VZkZKSzyzBGkvXRRx/Zt3Nzc63atWtbzz//vH3s119/tXx8fKx33nnHCRUWz+/7sSzLGjJkiNWnTx+n1GNKamqqJcnaunWrZVlXj4mXl5f13nvv2ed8//33liQrMTHRWWUWy+97sizLuu2226zHHnvMeUWVUrVq1aw33nijXByfPHk9WZZ7H5/z589bN9xwgxUfH+/QR3k6Vs7CGSwnuHz5svbs2aOYmBj7mIeHh2JiYpSYmOjEykrnhx9+UHBwsMLDwzVo0CAdO3bM2SUZk5ycrNOnTzscsypVqqhdu3Zufcy2bNmiWrVq6aabbtKIESN09uxZZ5dULGlpaZKk6tWrS5L27Nmj7Oxsh+PUqFEj1a9f322O0+97yrNs2TLVrFlTN998syZNmqTMzExnlFcsOTk5evfdd5WRkaGoqKhycXx+31Medzw+kjRq1Cj16tXL4ZhI5eNnydn4Zc9OcObMGeXk5CgoKMhhPCgoSAcOHHBSVaXTrl07LVmyRDfddJNOnTqlmTNnKjo6Wt988438/f2dXV6pnT59WpIKPGZ5r7mbv/zlL7rrrrsUFhamw4cPa/LkyerRo4cSExPl6enp7PL+UG5ursaOHasOHTro5ptvlnT1OHl7e6tq1aoOc93lOBXUkyQNHDhQoaGhCg4O1tdff60nnnhCBw8e1IcffujEagu3f/9+RUVF6dKlS6pcubI++ugjNWnSRElJSW57fArrSXK/45Pn3Xff1d69e7Vr1658r7n7z5IrIGDBiB49etj/3Lx5c7Vr106hoaFauXKl/va3vzmxMhTmr3/9q/3PzZo1U/PmzRUREaEtW7aoa9euTqysaEaNGqVvvvnG7e71u5bCenrkkUfsf27WrJnq1Kmjrl276vDhw4qIiPizy/xDN910k5KSkpSWlqb3339fQ4YM0datW51dVqkU1lOTJk3c7vhI0vHjx/XYY48pPj5evr6+zi6nXOISoRPUrFlTnp6e+T6NkZKSotq1azupKrOqVq2qG2+8UYcOHXJ2KUbkHZfyfMzCw8NVs2ZNtzhmo0eP1qeffqrPP/9cISEh9vHatWvr8uXL+vXXXx3mu8NxKqyngrRr106SXPZYeXt7q2HDhrrlllsUFxenyMhIvfTSS259fArrqSCufnykq5cAU1NT1apVK1WoUEEVKlTQ1q1b9fLLL6tChQoKCgpy22PlKghYTuDt7a1bbrlFmzZtso/l5uZq06ZNDtf03dmFCxd0+PBh1alTx9mlGBEWFqbatWs7HLP09HTt2LGj3ByzEydO6OzZsy59zCzL0ujRo/XRRx9p8+bNCgsLc3j9lltukZeXl8NxOnjwoI4dO+ayx+mPeipIUlKSJLn0sfqt3NxcZWVlueXxKUxeTwVxh+PTtWtX7d+/X0lJSfav1q1ba9CgQfY/l5dj5TTOvsv+evXuu+9aPj4+1pIlS6zvvvvOeuSRR6yqVatap0+fdnZpJfKPf/zD2rJli5WcnGz997//tWJiYqyaNWtaqampzi6tyM6fP2/t27fP2rdvnyXJmjNnjrVv3z7rxx9/tCzLsp555hmratWq1scff2x9/fXXVp8+faywsDDr4sWLTq68YNfq5/z589bjjz9uJSYmWsnJydZnn31mtWrVyrrhhhusS5cuObv0Qo0YMcKqUqWKtWXLFuvUqVP2r8zMTPuc4cOHW/Xr17c2b95s7d6924qKirKioqKcWPW1/VFPhw4dsmbNmmXt3r3bSk5Otj7++GMrPDzc6tSpk5MrL9jEiROtrVu3WsnJydbXX39tTZw40bLZbNbGjRsty3K/42NZ1+7J3Y7Ptfz+05DueKxcCQHLiebNm2fVr1/f8vb2ttq2bWt9+eWXzi6pxAYMGGDVqVPH8vb2turWrWsNGDDAOnTokLPLKpbPP//ckpTva8iQIZZlXX1Uw9SpU62goCDLx8fH6tq1q3Xw4EHnFn0N1+onMzPT6t69uxUYGGh5eXlZoaGh1rBhw1w+4BfUjyRr8eLF9jkXL160Ro4caVWrVs2qWLGi1a9fP+vUqVPOK/oP/FFPx44dszp16mRVr17d8vHxsRo2bGj985//tNLS0pxbeCEeeughKzQ01PL29rYCAwOtrl272sOVZbnf8bGsa/fkbsfnWn4fsNzxWLkSm2VZ1p93vgwAAKD84x4sAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELABlZsmSJbLZbIV+ffnll84uEQDKRAVnFwCg/Js1a1aBv8S4YcOGTqgGAMoeAQtAmevRo4dat27t1BoyMjJUqVIlp9YA4PrBJUIATnX06FHZbDa98MILeu211xQRESEfHx+1adNGu3btyjf/wIEDuueee1S9enX5+vqqdevWWr16tcOcvEuTW7du1ciRI1WrVi2FhITYX58/f77Cw8Pl5+entm3bavv27ercubM6d+4sSbpw4YIqVaqkxx57LN/3P3HihDw9PRUXF2f2jQBQrnAGC0CZS0tL05kzZxzGbDabatSoYd9evny5zp8/r7///e+y2Wx67rnndNddd+nIkSPy8vKSJH377bfq0KGD6tatq4kTJ6pSpUpauXKl+vbtqw8++ED9+vVz+B4jR45UYGCgpk2bpoyMDEnSggULNHr0aEVHR2vcuHE6evSo+vbtq2rVqtlDWOXKldWvXz+tWLFCc+bMkaenp33Nd955R5ZladCgQWXyXgEoJywAKCOLFy+2JBX45ePjY1mWZSUnJ1uSrBo1aljnzp2z7/vxxx9bkqxPPvnEPta1a1erWbNm1qVLl+xjubm5Vvv27a0bbrgh3/ft2LGjdeXKFft4VlaWVaNGDatNmzZWdna2fXzJkiWWJOu2226zj23YsMGSZK1bt86hp+bNmzvMA4CCcIkQQJmbP3++4uPjHb7WrVvnMGfAgAGqVq2afTs6OlqSdOTIEUnSuXPntHnzZvXv31/nz5/XmTNndObMGZ09e1axsbH64YcfdPLkSYc1hw0b5nD2affu3Tp79qyGDRumChX+7wT+oEGDHL63JMXExCg4OFjLli2zj33zzTf6+uuvdf/995fyHQFQ3nGJEECZa9u27R/e5F6/fn2H7bzA88svv0iSDh06JMuyNHXqVE2dOrXANVJTU1W3bl379u8/ufjjjz9Kyv/pxQoVKqhBgwYOYx4eHho0aJAWLFigzMxMVaxYUcuWLZOvr6/uvffea/YCAAQsAC7ht2eafsuyLElSbm6uJOnxxx9XbGxsgXN/H5z8/PxKVdPgwYP1/PPPa9WqVbrvvvu0fPly3XHHHapSpUqp1gVQ/hGwALiF8PBwSZKXl5diYmJKtEZoaKikq2fDunTpYh+/cuWKjh49qubNmzvMv/nmm9WyZUstW7ZMISEhOnbsmObNm1fCDgBcT7gHC4BbqFWrljp37qxFixbp1KlT+V7/+eef/3CN1q1bq0aNGnr99dd15coV+/iyZcvslyJ/74EHHtDGjRs1d+5c1ahRQz169Ch5EwCuG5zBAlDm1q1bpwMHDuQbb9++vTw8iv7/efPnz1fHjh3VrFkzDRs2TOHh4UpJSVFiYqJOnDihr7766pr7e3t7a8aMGXr00Ud1++23q3///jp69KiWLFmiiIgI2Wy2fPsMHDhQEyZM0EcffaQRI0bYHxkBANdCwAJQ5qZNm1bg+OLFi+0P9yyKJk2aaPfu3Zo5c6aWLFmis2fPqlatWmrZsmWh3+P3Ro8eLcuyNHv2bD3++OOKjIzU6tWrNWbMGPn6+uabHxQUpO7du2vt2rV64IEHilwrgOubzcq7gxQArlO5ubkKDAzUXXfdpddffz3f6/369dP+/ft16NAhJ1QHwB1xDxaA68qlS5f0+/+v/M9//qNz584VeDbt1KlTWrNmDWevABQLZ7AAXFe2bNmicePG6d5771WNGjW0d+9e/fvf/1bjxo21Z88eeXt7S5KSk5P13//+V2+88YZ27dqlw4cPq3bt2k6uHoC74B4sANeVBg0aqF69enr55Zd17tw5Va9eXYMHD9YzzzxjD1eStHXrVg0dOlT169fX0qVLCVcAioUzWAAAAIZxDxYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMP+P+3fHVhEceObAAAAAElFTkSuQmCC' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -195,14 +195,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 32,
    "id": "10645fdc-831b-4e82-82c3-06066eafb08d",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "17d3c9dc1aad41ceb0b3767a7fd9836c",
+       "model_id": "ee73dee35b604171bbbdbb7e4daf3eb1",
        "version_major": 2,
        "version_minor": 0
       },
@@ -210,25 +210,25 @@
        "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=1.0, min=-1.0, step=0.002…"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 32,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "6c62d5c5257c4942b14a032e6761d5b8",
+       "model_id": "e5887039de5a40419f5eb37f7bd770c3",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -241,7 +241,13 @@
     }
    ],
    "source": [
-    "sigmoid_reward_widget(lambda e, a: 1.0 / (1.0 + np.exp(e * (a < 0) - e * (a > 0) + 20 * a)))"
+    "def delayed_sig(e, a):\n",
+    "    if a > 0:\n",
+    "        return 1.0 / (1.0 + np.exp(-e + 20 * a))\n",
+    "    else:\n",
+    "        return 1.0 / (1.0 + np.exp(e - 20 * (1.0 + a) - 20))\n",
+    "\n",
+    "sigmoid_reward_widget(delayed_sig)"
    ]
   },
   {
@@ -362,7 +368,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.6"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

From 6eb05a5762ef86691ecbdc5ba603dfb8b9e629c2 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 28 Feb 2024 02:09:56 +0900
Subject: [PATCH 304/337] OffsetDelayed

---
 experiments/cf_asexual_evo.py |  7 +++++++
 src/emevo/reward_fn.py        | 12 ++++++++++++
 2 files changed, 19 insertions(+)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 6452e9ec..d589f6f5 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -52,6 +52,7 @@ class RewardKind(str, enum.Enum):
     DELAYED_SE = "delayed-se"
     LINEAR = "linear"
     EXPONENTIAL = "exponential"
+    OFFSET_DELAYED_SE = "offset-delayed-se"
     SIGMOID = "sigmoid"
     SIGMOID_01 = "sigmoid-01"
     SIGMOID_EXP = "sigmoid-exp"
@@ -597,6 +598,12 @@ def evolve(
             extractor=reward_extracor.extract_sigmoid,
             serializer=delayed_se_rs_withp if poison_reward else delayed_se_rs,
         )
+    elif reward_fn == RewardKind.OFFSET_DELAYED_SE:
+        reward_fn_instance = rfn.OffsetDelayedSEReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=delayed_se_rs_withp if poison_reward else delayed_se_rs,
+        )
     elif reward_fn == RewardKind.SINH:
         reward_fn_instance = rfn.SinhReward(
             **common_rewardfn_args,
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 750ad953..caa3845a 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -267,6 +267,18 @@ def serialise(self) -> dict[str, float | NDArray]:
         )
 
 
+class OffsetDelayedSEReward(DelayedSEReward):
+    def __call__(self, *args) -> jax.Array:
+        extracted, energy = self.extractor(*args)
+        weight = (10**self.scale) * self.weight
+        e = energy.reshape(-1, 1)  # (N, n_weights)
+        exp_pos = jnp.exp(-e + self.delay_scale * self.delay)
+        exp_neg = jnp.exp(e - self.delay_scale * (1.0 + self.delay) - self.delay_scale)
+        exp = jnp.where(self.delay > 0, exp_pos, exp_neg)
+        filtered = extracted / (1.0 + exp)
+        return jax.vmap(jnp.dot)(filtered, weight)
+
+
 def mutate_reward_fn(
     key: chex.PRNGKey,
     reward_fn_dict: dict[int, RF],

From e994450cbb2946b6b5f25b7d98258eae42a2b1a4 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 29 Feb 2024 18:12:06 +0900
Subject: [PATCH 305/337] Delayed sigmoid sinh

---
 experiments/cf_asexual_evo.py | 29 +++++++++++++++++++
 src/emevo/reward_fn.py        | 52 ++++++++++++++++++++++++++++++++---
 2 files changed, 77 insertions(+), 4 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index d589f6f5..6690da3c 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -53,6 +53,7 @@ class RewardKind(str, enum.Enum):
     LINEAR = "linear"
     EXPONENTIAL = "exponential"
     OFFSET_DELAYED_SE = "offset-delayed-se"
+    OFFSET_DELAYED_SINH = "offset-delayed-sinh"
     SIGMOID = "sigmoid"
     SIGMOID_01 = "sigmoid-01"
     SIGMOID_EXP = "sigmoid-exp"
@@ -122,6 +123,15 @@ def sigmoid_rs(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
     return w_dict | alpha_dict
 
 
+def delayed_sigmoid_rs(w: jax.Array, delay: jax.Array) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    delay_dict = rfn.serialize_weight(
+        delay,
+        ["delay_agent", "delay_food", "delay_wall", "delay_action"],
+    )
+    return w_dict | delay_dict
+
+
 def sigmoid_exp_rs(
     w: jax.Array,
     scale: jax.Array,
@@ -183,6 +193,17 @@ def sigmoid_rs_withp(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
     return w_dict | alpha_dict
 
 
+def delayed_sigmoid_rs_withp(w: jax.Array, delay: jax.Array) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(
+        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
+    )
+    delay_dict = rfn.serialize_weight(
+        delay,
+        ["delay_agent", "delay_food", "w_poison", "delay_wall", "delay_action"],
+    )
+    return w_dict | delay_dict
+
+
 def sigmoid_exp_rs_withp(
     w: jax.Array, scale: jax.Array, alpha: jax.Array
 ) -> dict[str, jax.Array]:
@@ -610,6 +631,14 @@ def evolve(
             extractor=reward_extracor.extract_linear,
             serializer=linear_rs_withp if poison_reward else linear_rs,
         )
+    elif reward_fn == RewardKind.OFFSET_DELAYED_SINH:
+        reward_fn_instance = rfn.OffsetDelayedSinhReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=delayed_sigmoid_rs_withp
+            if poison_reward
+            else delayed_sigmoid_rs,
+        )
     else:
         raise ValueError(f"Invalid reward_fn {reward_fn}")
 
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index caa3845a..38b04074 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -199,10 +199,10 @@ def __init__(
         std: float = 1.0,
         mean: float = 0.0,
     ) -> None:
-        k1, k2 = jax.random.split(key)
+        k1, k2, k3 = jax.random.split(key, 3)
         self.weight = jax.random.normal(k1, (n_agents, n_weights)) * std + mean
         self.scale = jax.random.normal(k2, (n_agents, n_weights)) * std + mean
-        self.alpha = jax.random.normal(k2, (n_agents, n_weights)) * std + mean
+        self.alpha = jax.random.normal(k3, (n_agents, n_weights)) * std + mean
         self.extractor = extractor
         self.serializer = serializer
 
@@ -242,10 +242,10 @@ def __init__(
         mean: float = 0.0,
         delay_scale: float = 20.0,
     ) -> None:
-        k1, k2 = jax.random.split(key)
+        k1, k2, k3 = jax.random.split(key, 3)
         self.weight = jax.random.normal(k1, (n_agents, n_weights)) * std + mean
         self.scale = jax.random.normal(k2, (n_agents, n_weights)) * std + mean
-        self.delay = jax.random.normal(k2, (n_agents, n_weights)) * std + mean
+        self.delay = jax.random.normal(k3, (n_agents, n_weights)) * std + mean
         self.extractor = extractor
         self.serializer = serializer
         self.delay_scale = delay_scale
@@ -279,6 +279,50 @@ def __call__(self, *args) -> jax.Array:
         return jax.vmap(jnp.dot)(filtered, weight)
 
 
+class OffsetDelayedSinhReward(RewardFn):
+    weight: jax.Array
+    delay: jax.Array
+    extractor: Callable[..., tuple[jax.Array, jax.Array]]
+    serializer: Callable[[jax.Array, jax.Array], dict[str, jax.Array]]
+    delay_scale: float
+    scale: float
+
+    def __init__(
+        self,
+        *,  # order of arguments are a bit confusing here...
+        key: chex.PRNGKey,
+        n_agents: int,
+        n_weights: int,
+        extractor: Callable[..., tuple[jax.Array, jax.Array]],
+        serializer: Callable[[jax.Array, jax.Array], dict[str, jax.Array]],
+        std: float = 1.0,
+        mean: float = 0.0,
+        scale: float = 2.5,
+        delay_scale: float = 20.0,
+    ) -> None:
+        k1, k2 = jax.random.split(key)
+        self.weight = jax.random.normal(k1, (n_agents, n_weights)) * std + mean
+        self.delay = jax.random.normal(k2, (n_agents, n_weights)) * std + mean
+        self.extractor = extractor
+        self.serializer = serializer
+        self.scale = scale
+        self.delay_scale = delay_scale
+
+    def __call__(self, *args) -> jax.Array:
+        extracted = self.extractor(*args)
+        extracted, energy = self.extractor(*args)
+        weight = jnp.sinh(self.weight * self.scale)
+        e = energy.reshape(-1, 1)  # (N, n_weights)
+        exp_pos = jnp.exp(-e + self.delay_scale * self.delay)
+        exp_neg = jnp.exp(e - self.delay_scale * (1.0 + self.delay) - self.delay_scale)
+        exp = jnp.where(self.delay > 0, exp_pos, exp_neg)
+        filtered = extracted / (1.0 + exp)
+        return jax.vmap(jnp.dot)(filtered, weight)
+
+    def serialise(self) -> dict[str, float | NDArray]:
+        return jax.tree_map(_item_or_np, self.serializer(self.weight, self.delay))
+
+
 def mutate_reward_fn(
     key: chex.PRNGKey,
     reward_fn_dict: dict[int, RF],

From ffbffd1329822726e3f0740038a2fe860025e209 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 1 Mar 2024 18:34:43 +0900
Subject: [PATCH 306/337] Idea of setting flat section in delayed sigmoid

---
 notebooks/reward_fn.ipynb | 34 ++++++++++++++++++----------------
 1 file changed, 18 insertions(+), 16 deletions(-)

diff --git a/notebooks/reward_fn.ipynb b/notebooks/reward_fn.ipynb
index 38a5e0ca..05b258ba 100644
--- a/notebooks/reward_fn.ipynb
+++ b/notebooks/reward_fn.ipynb
@@ -100,7 +100,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "822d21dfc1b042f1a1565c7f857a58a9",
+       "model_id": "910e7cc0f8034bb5aa7d940e34b65ac8",
        "version_major": 2,
        "version_minor": 0
       },
@@ -115,7 +115,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "73e6f78e248a4b3b8a3cebdba65d255a",
+       "model_id": "fc26b335dc124bef970a014184fb04b1",
        "version_major": 2,
        "version_minor": 0
       },
@@ -151,7 +151,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "8db90f4d55a34d10a0cbbbc505fe8285",
+       "model_id": "1098668abb05445a8b979a43d36a436b",
        "version_major": 2,
        "version_minor": 0
       },
@@ -166,7 +166,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "611215df35f44bd68e9750e19d1e3ad0",
+       "model_id": "65ba7d4a01e94a599293e403a72dbdec",
        "version_major": 2,
        "version_minor": 0
       },
@@ -195,14 +195,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 6,
    "id": "10645fdc-831b-4e82-82c3-06066eafb08d",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "ee73dee35b604171bbbdbb7e4daf3eb1",
+       "model_id": "123d3df68bb94b53b54f8fab0c84561c",
        "version_major": 2,
        "version_minor": 0
       },
@@ -210,25 +210,25 @@
        "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=1.0, min=-1.0, step=0.002…"
       ]
      },
-     "execution_count": 32,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "e5887039de5a40419f5eb37f7bd770c3",
+       "model_id": "a9658f73318845d49f5ab828a9782082",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -242,7 +242,9 @@
    ],
    "source": [
     "def delayed_sig(e, a):\n",
-    "    if a > 0:\n",
+    "    if abs(a) < 0.2:\n",
+    "        return np.ones_like(e)\n",
+    "    elif a > 0:\n",
     "        return 1.0 / (1.0 + np.exp(-e + 20 * a))\n",
     "    else:\n",
     "        return 1.0 / (1.0 + np.exp(e - 20 * (1.0 + a) - 20))\n",
@@ -252,7 +254,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 7,
    "id": "b91dd971-aa16-43ca-95e5-b20341f89df1",
    "metadata": {},
    "outputs": [],
@@ -294,14 +296,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 8,
    "id": "71c3a640-8966-4b43-b233-558c5e0e3b24",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "340796bd96c24048808059cc3c212322",
+       "model_id": "765749ea812f47d3b81158d5c72c1482",
        "version_major": 2,
        "version_minor": 0
       },
@@ -309,14 +311,14 @@
        "VBox(children=(interactive(children=(FloatSlider(value=1.25, description='alpha', max=2.5, step=0.0025), Outpu…"
       ]
      },
-     "execution_count": 31,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "508b2be48d584ded8e827df9c3c8de92",
+       "model_id": "da4a920c7ebf45719aff0613529be937",
        "version_major": 2,
        "version_minor": 0
       },

From 55289342ea4f35fae18051c899f91e3baa91d1a1 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 2 Mar 2024 02:52:45 +0900
Subject: [PATCH 307/337] bounded exp

---
 experiments/cf_asexual_evo.py | 7 +++++++
 src/emevo/reward_fn.py        | 8 ++++++++
 2 files changed, 15 insertions(+)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index d589f6f5..297dc09d 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -49,6 +49,7 @@
 
 
 class RewardKind(str, enum.Enum):
+    BOUNDED_EXP = "bounded-exp"
     DELAYED_SE = "delayed-se"
     LINEAR = "linear"
     EXPONENTIAL = "exponential"
@@ -574,6 +575,12 @@ def evolve(
             extractor=reward_extracor.extract_linear,
             serializer=exp_rs_withp if poison_reward else exp_rs,
         )
+    elif reward_fn == RewardKind.BOUNDED_EXP:
+        reward_fn_instance = rfn.BoundedExponentialReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_linear,
+            serializer=exp_rs_withp if poison_reward else exp_rs,
+        )
     elif reward_fn == RewardKind.SIGMOID:
         reward_fn_instance = rfn.SigmoidReward(
             **common_rewardfn_args,
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index caa3845a..77d8f445 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -136,6 +136,14 @@ def serialise(self) -> dict[str, float | NDArray]:
         return jax.tree_map(_item_or_np, self.serializer(self.weight, self.scale))
 
 
+class BoundedExponentialReward(ExponentialReward):
+    def __call__(self, *args) -> jax.Array:
+        extracted = self.extractor(*args)
+        scale = (self.scale + 1.0) * 0.5
+        weight = (10**scale) * self.weight
+        return jax.vmap(jnp.dot)(extracted, weight)
+
+
 class SigmoidReward(RewardFn):
     weight: jax.Array
     alpha: jax.Array

From dfe4aab87b1288f705efc6ea3c5ad1d3727ff2f4 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 2 Mar 2024 23:56:10 +0900
Subject: [PATCH 308/337] offset-delayed-sbe

---
 experiments/cf_asexual_evo.py | 35 +++++++++++++++++++++++++++--------
 src/emevo/reward_fn.py        | 13 +++++++++++++
 2 files changed, 40 insertions(+), 8 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index c30fb4a3..470d9f12 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -53,6 +53,7 @@ class RewardKind(str, enum.Enum):
     DELAYED_SE = "delayed-se"
     LINEAR = "linear"
     EXPONENTIAL = "exponential"
+    OFFSET_DELAYED_SBE = "offset-delayed-sbe"
     OFFSET_DELAYED_SE = "offset-delayed-se"
     OFFSET_DELAYED_SINH = "offset-delayed-sinh"
     SIGMOID = "sigmoid"
@@ -189,7 +190,7 @@ def sigmoid_rs_withp(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
     )
     alpha_dict = rfn.serialize_weight(
         alpha,
-        ["alpha_agent", "alpha_food", "w_poison", "alpha_wall", "alpha_action"],
+        ["alpha_agent", "alpha_food", "alpha_poison", "alpha_wall", "alpha_action"],
     )
     return w_dict | alpha_dict
 
@@ -198,11 +199,17 @@ def delayed_sigmoid_rs_withp(w: jax.Array, delay: jax.Array) -> dict[str, jax.Ar
     w_dict = rfn.serialize_weight(
         w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
     )
-    delay_dict = rfn.serialize_weight(
+    threshold_dict = rfn.serialize_weight(
         delay,
-        ["delay_agent", "delay_food", "w_poison", "delay_wall", "delay_action"],
+        [
+            "threshold_agent",
+            "threshold_food",
+            "threshold_poison",
+            "threshold_wall",
+            "threshold_action",
+        ],
     )
-    return w_dict | delay_dict
+    return w_dict | threshold_dict
 
 
 def sigmoid_exp_rs_withp(
@@ -213,7 +220,7 @@ def sigmoid_exp_rs_withp(
     )
     alpha_dict = rfn.serialize_weight(
         alpha,
-        ["alpha_agent", "alpha_food", "w_poison", "alpha_wall", "alpha_action"],
+        ["alpha_agent", "alpha_food", "alpha_poison", "alpha_wall", "alpha_action"],
     )
     scale_dict = rfn.serialize_weight(
         scale,
@@ -228,15 +235,21 @@ def delayed_se_rs_withp(
     w_dict = rfn.serialize_weight(
         w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
     )
-    delay_dict = rfn.serialize_weight(
+    threshold_dict = rfn.serialize_weight(
         delay,
-        ["delay_agent", "delay_food", "w_poison", "delay_wall", "delay_action"],
+        [
+            "threshold_agent",
+            "threshold_food",
+            "threshold_poison",
+            "threshold_wall",
+            "threshold_action",
+        ],
     )
     scale_dict = rfn.serialize_weight(
         scale,
         ["scale_agent", "scale_food", "scale_poison", "scale_wall", "scale_action"],
     )
-    return (w_dict | delay_dict) | scale_dict
+    return (w_dict | threshold_dict) | scale_dict
 
 
 def exec_rollout(
@@ -626,6 +639,12 @@ def evolve(
             extractor=reward_extracor.extract_sigmoid,
             serializer=delayed_se_rs_withp if poison_reward else delayed_se_rs,
         )
+    elif reward_fn == RewardKind.OFFSET_DELAYED_SBE:
+        reward_fn_instance = rfn.OffsetDelayedSBEReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=delayed_se_rs_withp if poison_reward else delayed_se_rs,
+        )
     elif reward_fn == RewardKind.OFFSET_DELAYED_SE:
         reward_fn_instance = rfn.OffsetDelayedSEReward(
             **common_rewardfn_args,
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 1c29b1de..7258ae9f 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -287,6 +287,19 @@ def __call__(self, *args) -> jax.Array:
         return jax.vmap(jnp.dot)(filtered, weight)
 
 
+class OffsetDelayedSBEReward(DelayedSEReward):
+    def __call__(self, *args) -> jax.Array:
+        extracted, energy = self.extractor(*args)
+        scale = (self.scale + 1.0) * 0.5
+        weight = (10**scale) * self.weight
+        e = energy.reshape(-1, 1)  # (N, n_weights)
+        exp_pos = jnp.exp(-e + self.delay_scale * self.delay)
+        exp_neg = jnp.exp(e - self.delay_scale * (1.0 + self.delay) - self.delay_scale)
+        exp = jnp.where(self.delay > 0, exp_pos, exp_neg)
+        filtered = extracted / (1.0 + exp)
+        return jax.vmap(jnp.dot)(filtered, weight)
+
+
 class OffsetDelayedSinhReward(RewardFn):
     weight: jax.Array
     delay: jax.Array

From 9bad7eac1c2c9e56617c90757414db65fa2d2310 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sun, 3 Mar 2024 15:19:59 +0900
Subject: [PATCH 309/337] Fix widget and saving state for poison

---
 src/emevo/analysis/qt_widget.py | 1 +
 src/emevo/exp_utils.py          | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index 103be322..7a08d7df 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -97,6 +97,7 @@ def __init__(
             space=env._physics,
             stated=self._get_stated(0),
             sensor_fn=env._get_sensors,
+            sc_color_opt=env._food_color,
         )
         self._env = env
         self._get_colors = get_colors
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 1b7eb0f9..fdef7315 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -251,6 +251,7 @@ def save_physstates(phys_states: list[SavedPhysicsState], path: Path) -> None:
         circle_is_active=concatenated.circle_is_active,
         static_circle_axy=concatenated.static_circle_axy,
         static_circle_is_active=concatenated.static_circle_is_active,
+        static_cirlce_label=concatenated.static_cirlce_label,
     )
 
 

From ccc9e2f9512132dc239a50c116ab11cb6f6c8a21 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sun, 3 Mar 2024 17:21:29 +0900
Subject: [PATCH 310/337] poison lv

---
 config/env/20240303-poison-lv.toml | 40 ++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 config/env/20240303-poison-lv.toml

diff --git a/config/env/20240303-poison-lv.toml b/config/env/20240303-poison-lv.toml
new file mode 100644
index 00000000..efcf65e7
--- /dev/null
+++ b/config/env/20240303-poison-lv.toml
@@ -0,0 +1,40 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 90
+n_food_sources = 2
+food_num_fn = [
+    ["logistic", 20, 0.01, 70],
+    ["logistic", 10, 0.01, 20],
+]
+food_loc_fn = [
+   ["gaussian", [360.0, 270.0], [80.0, 60.0]],
+   ["gaussian", [360.0, 90.0], [80.0, 60.0]],
+]
+food_color = [[254, 2, 162, 255], [2, 254, 162, 255]]
+food_energy_coef = [1.0, -0.1]
+agent_loc_fn = "uniform"
+observe_food_label = true
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 24
+sensor_length = 200.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 400.0
+force_energy_consumption = 2e-5
+basic_energy_consumption = 2e-4
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 7a9f69d150892393a71083c030c4108d8a4504c8 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 4 Mar 2024 10:54:18 +0900
Subject: [PATCH 311/337] typo

---
 src/emevo/exp_utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index fdef7315..88a2311c 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -251,7 +251,7 @@ def save_physstates(phys_states: list[SavedPhysicsState], path: Path) -> None:
         circle_is_active=concatenated.circle_is_active,
         static_circle_axy=concatenated.static_circle_axy,
         static_circle_is_active=concatenated.static_circle_is_active,
-        static_cirlce_label=concatenated.static_cirlce_label,
+        static_cirlce_label=concatenated.static_circle_label,
     )
 
 

From 4d2c665cb08b1708a942c297b1c874cf2710485d Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 5 Mar 2024 01:52:58 +0900
Subject: [PATCH 312/337] Use negative_offset in offset delayed

---
 src/emevo/reward_fn.py | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 7258ae9f..9dbfc851 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -237,6 +237,7 @@ class DelayedSEReward(RewardFn):
     extractor: Callable[..., tuple[jax.Array, jax.Array]]
     serializer: Callable[[jax.Array, jax.Array, jax.Array], dict[str, jax.Array]]
     delay_scale: float
+    negative_offset: float
 
     def __init__(
         self,
@@ -249,6 +250,7 @@ def __init__(
         std: float = 1.0,
         mean: float = 0.0,
         delay_scale: float = 20.0,
+        negative_offset: float = 20.0,
     ) -> None:
         k1, k2, k3 = jax.random.split(key, 3)
         self.weight = jax.random.normal(k1, (n_agents, n_weights)) * std + mean
@@ -257,6 +259,7 @@ def __init__(
         self.extractor = extractor
         self.serializer = serializer
         self.delay_scale = delay_scale
+        self.negative_offset = negative_offset
 
     def __call__(self, *args) -> jax.Array:
         extracted, energy = self.extractor(*args)
@@ -281,7 +284,9 @@ def __call__(self, *args) -> jax.Array:
         weight = (10**self.scale) * self.weight
         e = energy.reshape(-1, 1)  # (N, n_weights)
         exp_pos = jnp.exp(-e + self.delay_scale * self.delay)
-        exp_neg = jnp.exp(e - self.delay_scale * (1.0 + self.delay) - self.delay_scale)
+        exp_neg = jnp.exp(
+            e - self.delay_scale * (1.0 + self.delay) - self.negative_offset
+        )
         exp = jnp.where(self.delay > 0, exp_pos, exp_neg)
         filtered = extracted / (1.0 + exp)
         return jax.vmap(jnp.dot)(filtered, weight)
@@ -294,7 +299,9 @@ def __call__(self, *args) -> jax.Array:
         weight = (10**scale) * self.weight
         e = energy.reshape(-1, 1)  # (N, n_weights)
         exp_pos = jnp.exp(-e + self.delay_scale * self.delay)
-        exp_neg = jnp.exp(e - self.delay_scale * (1.0 + self.delay) - self.delay_scale)
+        exp_neg = jnp.exp(
+            e - self.delay_scale * (1.0 + self.delay) - self.negative_offset
+        )
         exp = jnp.where(self.delay > 0, exp_pos, exp_neg)
         filtered = extracted / (1.0 + exp)
         return jax.vmap(jnp.dot)(filtered, weight)

From 00c01566f2f398acfe68d1290b28d4efafc07f43 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 5 Mar 2024 02:00:14 +0900
Subject: [PATCH 313/337] Revert "Use negative_offset in offset delayed"

This reverts commit 4d2c665cb08b1708a942c297b1c874cf2710485d.
---
 src/emevo/reward_fn.py | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 9dbfc851..7258ae9f 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -237,7 +237,6 @@ class DelayedSEReward(RewardFn):
     extractor: Callable[..., tuple[jax.Array, jax.Array]]
     serializer: Callable[[jax.Array, jax.Array, jax.Array], dict[str, jax.Array]]
     delay_scale: float
-    negative_offset: float
 
     def __init__(
         self,
@@ -250,7 +249,6 @@ def __init__(
         std: float = 1.0,
         mean: float = 0.0,
         delay_scale: float = 20.0,
-        negative_offset: float = 20.0,
     ) -> None:
         k1, k2, k3 = jax.random.split(key, 3)
         self.weight = jax.random.normal(k1, (n_agents, n_weights)) * std + mean
@@ -259,7 +257,6 @@ def __init__(
         self.extractor = extractor
         self.serializer = serializer
         self.delay_scale = delay_scale
-        self.negative_offset = negative_offset
 
     def __call__(self, *args) -> jax.Array:
         extracted, energy = self.extractor(*args)
@@ -284,9 +281,7 @@ def __call__(self, *args) -> jax.Array:
         weight = (10**self.scale) * self.weight
         e = energy.reshape(-1, 1)  # (N, n_weights)
         exp_pos = jnp.exp(-e + self.delay_scale * self.delay)
-        exp_neg = jnp.exp(
-            e - self.delay_scale * (1.0 + self.delay) - self.negative_offset
-        )
+        exp_neg = jnp.exp(e - self.delay_scale * (1.0 + self.delay) - self.delay_scale)
         exp = jnp.where(self.delay > 0, exp_pos, exp_neg)
         filtered = extracted / (1.0 + exp)
         return jax.vmap(jnp.dot)(filtered, weight)
@@ -299,9 +294,7 @@ def __call__(self, *args) -> jax.Array:
         weight = (10**scale) * self.weight
         e = energy.reshape(-1, 1)  # (N, n_weights)
         exp_pos = jnp.exp(-e + self.delay_scale * self.delay)
-        exp_neg = jnp.exp(
-            e - self.delay_scale * (1.0 + self.delay) - self.negative_offset
-        )
+        exp_neg = jnp.exp(e - self.delay_scale * (1.0 + self.delay) - self.delay_scale)
         exp = jnp.where(self.delay > 0, exp_pos, exp_neg)
         filtered = extracted / (1.0 + exp)
         return jax.vmap(jnp.dot)(filtered, weight)

From e66dc422b16921400422fa9211446ea920cb8a2f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 5 Mar 2024 02:13:17 +0900
Subject: [PATCH 314/337] delay60

---
 config/gops/20240305-0401-clipped-delay60.toml | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 config/gops/20240305-0401-clipped-delay60.toml

diff --git a/config/gops/20240305-0401-clipped-delay60.toml b/config/gops/20240305-0401-clipped-delay60.toml
new file mode 100644
index 00000000..cc31226b
--- /dev/null
+++ b/config/gops/20240305-0401-clipped-delay60.toml
@@ -0,0 +1,18 @@
+path = "emevo.genetic_ops.BernoulliMixtureMutation"
+init_std = 0.1
+init_mean = 0.0
+
+[init_kwargs]
+delay_scale = 60.0
+
+[params]
+mutation_prob = 0.4
+
+[params.mutator]
+path = "emevo.genetic_ops.UniformMutation"
+
+[params.mutator.params]
+min_noise = -0.1
+max_noise = 0.1
+clip_min = -1.0
+clip_max = 1.0
\ No newline at end of file

From d809adff5dca769077ca29240aeedabd011481ec Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 6 Mar 2024 21:50:52 +0900
Subject: [PATCH 315/337] delay3216

---
 ...40306-mutation-0401-clipped-delay3216.toml | 19 ++++++++
 notebooks/reward_fn.ipynb                     | 44 +++++++++----------
 src/emevo/reward_fn.py                        |  7 ++-
 3 files changed, 46 insertions(+), 24 deletions(-)
 create mode 100644 config/gops/20240306-mutation-0401-clipped-delay3216.toml

diff --git a/config/gops/20240306-mutation-0401-clipped-delay3216.toml b/config/gops/20240306-mutation-0401-clipped-delay3216.toml
new file mode 100644
index 00000000..f3abcb9b
--- /dev/null
+++ b/config/gops/20240306-mutation-0401-clipped-delay3216.toml
@@ -0,0 +1,19 @@
+path = "emevo.genetic_ops.BernoulliMixtureMutation"
+init_std = 0.1
+init_mean = 0.0
+
+[init_kwargs]
+delay_scale = 32.0
+delay_neg_offset = 16.0
+
+[params]
+mutation_prob = 0.4
+
+[params.mutator]
+path = "emevo.genetic_ops.UniformMutation"
+
+[params.mutator.params]
+min_noise = -0.1
+max_noise = 0.1
+clip_min = -1.0
+clip_max = 1.0
\ No newline at end of file
diff --git a/notebooks/reward_fn.ipynb b/notebooks/reward_fn.ipynb
index 05b258ba..bf4f08a3 100644
--- a/notebooks/reward_fn.ipynb
+++ b/notebooks/reward_fn.ipynb
@@ -100,7 +100,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "910e7cc0f8034bb5aa7d940e34b65ac8",
+       "model_id": "efb07f7e0f7d415e97c806bf0dd344f7",
        "version_major": 2,
        "version_minor": 0
       },
@@ -115,18 +115,18 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "fc26b335dc124bef970a014184fb04b1",
+       "model_id": "8eadfcc4e5fc49f8b371cc43f2d1da6a",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAlgAAAJYCAYAAAC+ZpjcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABFFElEQVR4nO3deVRV9f7/8dcBGUQFFRBUFETLKcURwsQsUbJJbbK0HG7ZN5WsuN7SfipqA01fM82b1i3plpXN2a1Mc+ZKWg5l3fSqOSsgDqCQgrB/f7g4346AMXzonIPPx1pnLfdn7/057/fZsny59z4bm2VZlgAAAGCMh7MLAAAAqG0IWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWEAtEBERoVGjRjm7jItKTU2VzWbT3r17/3Bbd+inpthsNk2fPr1S+5w+fVr33XefQkNDZbPZ9PDDD9dIbQAqjoAFuLBt27bptttuU3h4uHx9fdW8eXP1799fc+fOdXZpcCFPP/20UlNTNXbsWL311lu65557nF0ScMmzWZZlObsIAKWtX79e11xzjVq2bKmRI0cqNDRUBw4c0Lfffqvdu3dr165d9m3Pnj0rDw8PeXl5ObHiiysqKlJhYaF8fHxks9kuum1ERIT69u2r1NTUP6c4F2Kz2ZScnFyps1hXXnml6tSpo7S0tJorDECl1HF2AQDK9tRTTykgIEDfffedGjZs6LAuKyvLYdnHx+dPrKxqPD095enpWaPvce7cORUXF8vb27tG36c68vLyVK9ePaNzZmVlqUOHDkbnBFA9XCIEXNTu3bvVsWPHUuFKkpo0aeKwXNY9Sz/++KOuvvpq1a1bV2FhYXryySe1cOHCUvdBRURE6MYbb9Tq1avVo0cP1a1bV506ddLq1aslSR9//LE6deokX19fde/eXVu2bClVz8qVKxUXF6d69eqpYcOGGjRokH755ReHbcq6B8uyLD355JMKCwuTn5+frrnmGv38888V+nz27t0rm82mF154QbNnz1br1q3l4+Oj//znP5Kk7du367bbblPjxo3l6+urHj16aMmSJfb9T548KU9PT82ZM8c+lp2dLQ8PDwUGBur3J/fHjh2r0NBQ+/K6det0++23q2XLlvLx8VGLFi30yCOP6LfffnOocdSoUapfv752796t66+/Xg0aNNDw4cMlnT/r+Mgjjyg4OFgNGjTQzTffrIMHD1ao9xKrV6+WzWbTnj179MUXX8hms9k/45J177//vp566imFhYXJ19dX/fr1czj7CaBmcAYLcFHh4eFKT0/XTz/9pCuuuKJS+x46dEjXXHONbDabJk+erHr16ukf//hHuWe6du3apWHDhul//ud/dPfdd+uFF17QTTfdpPnz5+vxxx/XuHHjJEkpKSm64447tGPHDnl4nP//2TfffKOBAwcqMjJS06dP12+//aa5c+fqqquu0ubNmxUREVFundOmTdOTTz6p66+/Xtdff702b96sAQMGqKCgoMK9Lly4UGfOnNH9998vHx8fNW7cWD///LOuuuoqNW/eXJMmTVK9evX0/vvva/Dgwfroo480ZMgQNWzYUFdccYXWrl2rCRMmSJLS0tJks9l0/Phx/ec//1HHjh0lnQ9UcXFx9vf84IMPlJ+fr7FjxyowMFAbN27U3LlzdfDgQX3wwQcO9Z07d04JCQnq3bu3XnjhBfn5+UmS7rvvPr399tsaNmyYevXqpZUrV+qGG26ocN+S1L59e7311lt65JFHFBYWpr/+9a+SpODgYHuQfeaZZ+Th4aGJEycqJydHzz33nIYPH64NGzZU6r0AVJIFwCUtW7bM8vT0tDw9Pa3Y2Fjr0Ucftb7++muroKCg1Lbh4eHWyJEj7csPPvigZbPZrC1bttjHjh07ZjVu3NiSZO3Zs8dhX0nW+vXr7WNff/21JcmqW7eutW/fPvv4ggULLEnWqlWr7GNdunSxmjRpYh07dsw+9sMPP1geHh7WiBEj7GMLFy50eO+srCzL29vbuuGGG6zi4mL7do8//rglyaGfsuzZs8eSZPn7+1tZWVkO6/r162d16tTJOnPmjH2suLjY6tWrl3XZZZfZx8aPH2+FhITYl5OSkqw+ffpYTZo0sV555RX752az2ayXXnrJvl1+fn6pelJSUiybzebweY0cOdKSZE2aNMlh261bt1qSrHHjxjmMDxs2zJJkJScnX7T3C4WHh1s33HCDw9iqVassSVb79u2ts2fP2sdfeuklS5K1bdu2Sr0HgMrhEiHgovr376/09HTdfPPN+uGHH/Tcc88pISFBzZs3d7jUVZalS5cqNjZWXbp0sY81btzYfnnqQh06dFBsbKx9OSYmRpJ07bXXqmXLlqXGf/31V0nSkSNHtHXrVo0aNUqNGze2b9e5c2f1799fX375Zbk1fvPNNyooKNCDDz7ocNN7ZR8xcOuttyo4ONi+fPz4ca1cuVJ33HGHTp06pezsbGVnZ+vYsWNKSEjQzp07dejQIUlSXFycMjMztWPHDknnz1T16dNHcXFxWrdunaTzZ7Usy3I4g1W3bl37n/Py8pSdna1evXrJsqwyL6GOHTvWYbnkcyk5c1bV3iti9OjRDveklfRRcgwB1AwCFuDCevbsqY8//lgnTpzQxo0bNXnyZJ06dUq33Xab/V6jsuzbt09t2rQpNV7WmCSHECVJAQEBkqQWLVqUOX7ixAn7+0hS27ZtS83Zvn17ZWdnKy8vr9waJemyyy5zGA8ODlajRo3K3KcsrVq1cljetWuXLMvS1KlTFRwc7PBKTk6W9H9fEigJG+vWrVNeXp62bNmiuLg49enTxx6w1q1bJ39/f0VFRdnfY//+/fZQWb9+fQUHB+vqq6+WJOXk5DjUU6dOHYWFhZXq3cPDQ61bt3YYL+tzrK4Lj23JZ1tyDAHUDO7BAtyAt7e3evbsqZ49e+ryyy/X6NGj9cEHH9gDQ3WV9+2+8sYtF3q6y+/PJklScXGxJGnixIlKSEgoc5+SoNmsWTO1atVKa9euVUREhCzLUmxsrIKDg/XQQw9p3759WrdunXr16mW/56yoqEj9+/fX8ePH9dhjj6ldu3aqV6+eDh06pFGjRtnfv4SPj499X2dwh2MI1EYELMDN9OjRQ9L5y3PlCQ8PL/ObYqa/PRYeHi5J9ktsv7d9+3YFBQWV+0iCkn137typyMhI+/jRo0erdXalZC4vLy/Fx8f/4fZxcXFau3atWrVqpS5duqhBgwaKiopSQECAli5dqs2bN2vGjBn27bdt26b//ve/evPNNzVixAj7+PLlyytcY3h4uIqLi7V7926Hs1ZlfY4A3BOXCAEXtWrVqjLPMpTcv3Oxy0kJCQlKT0/X1q1b7WPHjx/XokWLjNbYtGlTdenSRW+++aZOnjxpH//pp5+0bNkyXX/99eXuGx8fLy8vL82dO9ehz9mzZ1erpiZNmqhv375asGBBmSH06NGjDstxcXHau3evFi9ebL9k6OHhoV69emnWrFkqLCx0uP+q5IzQ72u2LEsvvfRShWscOHCgJDk8IkKqfu8AXAdnsAAX9eCDDyo/P19DhgxRu3btVFBQoPXr12vx4sWKiIjQ6NGjy9330Ucf1dtvv63+/fvrwQcftD+moWXLljp+/PgfPkm9Mp5//nkNHDhQsbGxuvfee+2PaQgICLjo08iDg4M1ceJEpaSk6MYbb9T111+vLVu26KuvvlJQUFC1apo3b5569+6tTp06acyYMYqMjFRmZqbS09N18OBB/fDDD/ZtS8LTjh079PTTT9vH+/Tpo6+++ko+Pj7q2bOnfbxdu3Zq3bq1Jk6cqEOHDsnf318fffRRpc66denSRXfddZf+/ve/KycnR7169dKKFSt4PhVQixCwABf1wgsv6IMPPtCXX36pV199VQUFBWrZsqXGjRunKVOmlPkA0hItWrTQqlWrNGHCBD399NMKDg7W+PHjVa9ePU2YMEG+vr7G6oyPj9fSpUuVnJysadOmycvLS1dffbWeffbZUjegX+jJJ5+Ur6+v5s+fr1WrVikmJkbLli2r9POgLtShQwd9//33mjFjhlJTU3Xs2DE1adJEXbt21bRp0xy2bdu2rZo0aaKsrCz17t3bPl4SvKKjox2eH+bl5aXPP/9cEyZMUEpKinx9fTVkyBAlJiY63Aj/R9544w0FBwdr0aJF+vTTT3Xttdfqiy++KPXFAgDuid9FCFxCHn74YS1YsECnT5+u8V9bAwCXMu7BAmqpC39ty7Fjx/TWW2+pd+/ehCsAqGFcIgRqqdjYWPXt21ft27dXZmamXn/9deXm5mrq1KnOLg0VUFRUVOqG/AvVr19f9evX/5MqAlAZBCyglrr++uv14Ycf6tVXX5XNZlO3bt30+uuvq0+fPs4uDRVw4MCBP7yHLTk5+aJfJADgPNyDBQAu6MyZM0pLS7voNpGRkQ7PEAPgOghYAAAAhnGTOwAAgGHcg1VBxcXFOnz4sBo0aGD0IY0AANR2lmXp1KlTatasmVN/N+efiYBVQYcPH+YBgAAAVMOBAwcUFhbm7DL+FASsCmrQoIGk8385/P39jcxZWFioZcuWacCAAfLy8jIyp7PRk3ugJ9dX2/qR6Mld1ERPubm5atGihf3f0ksBAauCSi4L+vv7Gw1Yfn5+8vf3r1U/mPTk+ujJ9dW2fiR6chc12dOldIvNpXEhFAAA4E9EwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMc9mANW/ePEVERMjX11cxMTHauHFjudumpqbKZrM5vHx9fe3rCwsL9dhjj6lTp06qV6+emjVrphEjRujw4cN/RisAAOAS45IBa/HixUpKSlJycrI2b96sqKgoJSQkKCsrq9x9/P39deTIEftr37599nX5+fnavHmzpk6dqs2bN+vjjz/Wjh07dPPNN/8Z7QAAgEtMHWcXUJZZs2ZpzJgxGj16tCRp/vz5+uKLL/TGG29o0qRJZe5js9kUGhpa5rqAgAAtX77cYezll19WdHS09u/fr5YtW5ptAAAAXNJcLmAVFBRo06ZNmjx5sn3Mw8ND8fHxSk9PL3e/06dPKzw8XMXFxerWrZuefvppdezYsdztc3JyZLPZ1LBhwzLXnz17VmfPnrUv5+bmSjp/ubGwsLCSXZWtZB5T87kCenIP9OT6als/Ej25i5roqTZ9PhVlsyzLcnYRv3f48GE1b95c69evV2xsrH380Ucf1Zo1a7Rhw4ZS+6Snp2vnzp3q3LmzcnJy9MILL2jt2rX6+eefFRYWVmr7M2fO6KqrrlK7du20aNGiMuuYPn26ZsyYUWr8nXfekZ+fXzU6BADg0pKfn69hw4YpJydH/v7+zi7nT1ErAtaFCgsL1b59e91111164oknSq279dZbdfDgQa1evbrcA13WGawWLVooOzvb2F+OwsJCLV++XP3795eXl5eROZ2NntwDPbm+2taPRE/uoiZ6ys3NVVBQ0CUVsFzuEmFQUJA8PT2VmZnpMJ6ZmVnuPVYX8vLyUteuXbVr1y6H8cLCQt1xxx3at2+fVq5cedGD7OPjIx8fnzLnNv1DVBNzOhs9uQd6cn21rR+JntyFyZ5q22dTES73LUJvb291795dK1assI8VFxdrxYoVDme0LqaoqEjbtm1T06ZN7WMl4Wrnzp365ptvFBgYaLx2AAAAyQXPYElSUlKSRo4cqR49eig6OlqzZ89WXl6e/VuFI0aMUPPmzZWSkiJJmjlzpq688kq1adNGJ0+e1PPPP699+/bpvvvuk3Q+XN12223avHmz/vWvf6moqEgZGRmSpMaNG8vb29s5jQIAgFrJJQPW0KFDdfToUU2bNk0ZGRnq0qWLli5dqpCQEEnS/v375eHxfyffTpw4oTFjxigjI0ONGjVS9+7dtX79enXo0EGSdOjQIS1ZskSS1KVLF4f3WrVqlfr27fun9AUAAC4NLhmwJCkxMVGJiYllrlu9erXD8osvvqgXX3yx3LkiIiLkYvfyAwCAWszl7sECAABwdwQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYS4ZsObNm6eIiAj5+voqJiZGGzduLHfb1NRU2Ww2h5evr6/DNh9//LEGDBigwMBA2Ww2bd26tYY7AAAAlzKXC1iLFy9WUlKSkpOTtXnzZkVFRSkhIUFZWVnl7uPv768jR47YX/v27XNYn5eXp969e+vZZ5+t6fIBAABUx9kFXGjWrFkaM2aMRo8eLUmaP3++vvjiC73xxhuaNGlSmfvYbDaFhoaWO+c999wjSdq7d6/xegEAAC7kUgGroKBAmzZt0uTJk+1jHh4eio+PV3p6ern7nT59WuHh4SouLla3bt309NNPq2PHjtWq5ezZszp79qx9OTc3V5JUWFiowsLCas1domQeU/O5AnpyD/Tk+mpbPxI9uYua6Kk2fT4VZbMsy3J2ESUOHz6s5s2ba/369YqNjbWPP/roo1qzZo02bNhQap/09HTt3LlTnTt3Vk5Ojl544QWtXbtWP//8s8LCwhy23bt3r1q1aqUtW7aoS5cuF61l+vTpmjFjRqnxd955R35+flVrEACAS1B+fr6GDRumnJwc+fv7O7ucP4VLncGqitjYWIcw1qtXL7Vv314LFizQE088UeV5J0+erKSkJPtybm6uWrRooQEDBhj7y1FYWKjly5erf//+8vLyMjKns9GTe6An11fb+pHoyV3URE8lV4EuJS4VsIKCguTp6anMzEyH8czMzIveY/V7Xl5e6tq1q3bt2lWtWnx8fOTj41Pm/KZ/iGpiTmejJ/dAT66vtvUj0ZO7MNlTbftsKsKlvkXo7e2t7t27a8WKFfax4uJirVixwuEs1cUUFRVp27Ztatq0aU2VCQAAcFEudQZLkpKSkjRy5Ej16NFD0dHRmj17tvLy8uzfKhwxYoSaN2+ulJQUSdLMmTN15ZVXqk2bNjp58qSef/557du3T/fdd599zuPHj2v//v06fPiwJGnHjh2SpNDQ0AqfGQMAAKgolwtYQ4cO1dGjRzVt2jRlZGSoS5cuWrp0qUJCQiRJ+/fvl4fH/514O3HihMaMGaOMjAw1atRI3bt31/r169WhQwf7NkuWLLEHNEm68847JUnJycmaPn36n9MYAAC4ZLhcwJKkxMREJSYmlrlu9erVDssvvviiXnzxxYvON2rUKI0aNcpQdQAAABfnUvdgAQAA1AYELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEVDlhLlizR4cOHa7IWAACAWqHCAWvIkCFavXq1fTkyMlJLliypiZoAAADcWoUDVoMGDXTy5En78t69e3X69OmaqAkAAMCt1anohtHR0XrqqaeUmZmpgIAASdKXX36pjIyMcvex2Wx65JFHql8lAACAG6lwwPr73/+uESNG6IknnpB0Pjy98847euedd8rdh4AFAAAuRRUOWG3atNH69et15swZZWVlKSIiQrNnz9agQYNqsj4AAAC3U+GAVcLX11ctW7ZUcnKyrr32WoWHh9dEXQAAAG6r0gGrRHJysv3PR44cUVZWltq0aaN69eoZKQwAAMBdVetBo5999pnatWunsLAwdevWTRs2bJAkZWdnq2vXrvr0009N1AgAAOBWqhywPv/8c91yyy0KCgpScnKyLMuyrwsKClLz5s21cOFCI0UCAAC4kyoHrJkzZ6pPnz5KS0vT+PHjS62PjY3Vli1bqlUcAACAO6pywPrpp590xx13lLs+JCREWVlZVZ0eAADAbVU5YPn5+SkvL6/c9b/++qsCAwOrOj0AAIDbqnLAuuaaa/Tmm2/q3LlzpdZlZGTotdde04ABA6pVHAAAgDuqcsB66qmndPDgQfXs2VMLFiyQzWbT119/rSlTpqhTp06yLMvhUQ4AAACXiioHrLZt2yotLU2BgYGaOnWqLMvS888/r6efflqdOnXSunXrFBERYbBUAAAA91DlB41KUseOHfXNN9/oxIkT2rVrl4qLixUZGang4GBT9QEAALidagWsEo0aNVLPnj1NTAUAAOD2qvUk99zcXM2YMUPR0dEKCQlRSEiIoqOjNXPmTOXm5pqqEQAAwK1UOWAdPnxYXbt21YwZM3T69GldddVVuuqqq5SXl6fp06erW7duOnLkiMlaAQAA3EKVLxE+9thjysjI0L/+9S9df/31Duu++uor3X777Zo0aZLefPPNahcJAADgTqp8Bmvp0qV6+OGHS4UrSRo4cKAmTJigL7/8slrFAQAAuKMqB6y8vDyFhISUuz40NPSiT3oHAACoraocsDp06KB3331XBQUFpdYVFhbq3XffVYcOHapVHAAAgDuq1j1YQ4cOVXR0tMaNG6fLL79ckrRjxw7Nnz9fP/74oxYvXmysUAAAAHdR5YB1++23Ky8vT5MmTdIDDzwgm80mSbIsS02aNNEbb7yh2267zVihAAAA7qJaDxodNWqU7r77bn3//ffat2+fJCk8PFw9evRQnTpGnmEKAADgdqqdgurUqaMrr7xSV155pYl6AAAA3F6lbnI/cuSI2rVrp6lTp150uylTpqh9+/bKysqqVnEAAADuqFIB66WXXtLx48f12GOPXXS7xx57TMePH9fcuXOrVRwAAIA7qlTA+uKLL3TXXXepfv36F92uQYMGGjZsmJYsWVKt4gAAANxRpQLW7t271blz5wpt27FjR+3atatKRQEAALizSgUsT0/PMh8sWpbCwkJ5eFT5OaYAAABuq1IJqHXr1kpLS6vQtv/+97/VunXrKhUFAADgzioVsIYMGaIPPvhA6enpF93u22+/1fvvv68hQ4ZUqzgAAAB3VKmAlZSUpLCwMA0YMEDPPvusDh065LD+0KFDevbZZzVgwACFhYXpkUceMVosAACAO6hUwGrQoIG++eYbtW7dWpMnT1bLli3VuHFjhYeHq3HjxmrZsqUmT56sVq1aafny5fL396+pugEAAFxWpZ/kHhkZqU2bNunDDz/UkiVLtH37duXm5qpVq1Zq166dbrrpJt122238qhwAAHDJqlIK8vT01NChQzV06FDT9QAAALg9nqMAAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADKvwYxpmzpxZ6cltNpumTp1a6f0AAADcWYUD1vTp00uN2Ww2SZJlWaXGLcsiYAEAgEtShS8RFhcXO7wOHDigTp066a677tLGjRuVk5OjnJwcbdiwQXfeeaeioqJ04MCBmqwdAADAJVX5Hqzx48frsssu09tvv60ePXqoQYMGatCggXr27KlFixapdevWGj9+fJULmzdvniIiIuTr66uYmBht3Lix3G1TU1Nls9kcXr6+vg7bWJaladOmqWnTpqpbt67i4+O1c+fOKtcHAABQnioHrJUrV+raa68td32/fv20YsWKKs29ePFiJSUlKTk5WZs3b1ZUVJQSEhKUlZVV7j7+/v46cuSI/bVv3z6H9c8995zmzJmj+fPna8OGDapXr54SEhJ05syZKtUIAABQnir/RmZfX1+lp6dr7NixZa5fv359qbNIFTVr1iyNGTNGo0ePliTNnz9fX3zxhd544w1NmjSpzH1sNptCQ0PLXGdZlmbPnq0pU6Zo0KBBkqR//vOfCgkJ0aeffqo777yzSnVWh2VZKvjNUlGBhwp+s1R8rvhPr6EmnCukJ3dAT66vtvUj0ZO7KOnpwvurUTlVDljDhw/XnDlz1LBhQz344INq3bq1JGn37t2aM2eO3nnnHU2YMKHS8xYUFGjTpk2aPHmyfczDw0Px8fFKT08vd7/Tp08rPDxcxcXF6tatm55++ml17NhRkrRnzx5lZGQoPj7evn1AQIBiYmKUnp5eZsA6e/aszp49a1/Ozc2VJBUWFqqwsLDSfZXq8zdLU64/Lqmn1r10vNrzuRZ6cg/05PpqWz8SPbmLnrr22kLZ/G1GZjPx76a7qXLAevbZZ5Wdna2XX35Z8+bNk4fH+auNxcXFsixLd911l5599tlKz5udna2ioiKFhIQ4jIeEhGj79u1l7tO2bVu98cYb6ty5s3JycvTCCy+oV69e+vnnnxUWFqaMjAz7HBfOWbLuQikpKZoxY0ap8WXLlsnPz6/SfV2oqMBDUs9qzwMAQE1YuXKlPL3NnJXLz883Mo87qXLA8vb21ltvvaW//e1v+vLLL+33PIWHh2vgwIGKiooyVuQfiY2NVWxsrH25V69eat++vRYsWKAnnniiSnNOnjxZSUlJ9uXc3Fy1aNFCAwYMkL+/f7VrtixL115baL+XzcvLq9pzuoLCQnpyB/Tk+mpbPxI9uYuSnhKuv1be3t5G5iy5CnQpqVLAys/P1913361bb71Vw4cPV+fOnY0VFBQUJE9PT2VmZjqMZ2ZmlnuP1YW8vLzUtWtX7dq1S5Ls+2VmZqpp06YOc3bp0qXMOXx8fOTj41Pm3KZ+iGz+Nnl6F6uev3ct+sGkJ3dAT66vtvUj0ZO7KOnJ29tcT7Xls6mMKn2L0M/PT998802NnPLz9vZW9+7dHb6BWFxcrBUrVjicpbqYoqIibdu2zR6mWrVqpdDQUIc5c3NztWHDhgrPCQAAUFFVfkxD7969L3rTeXUkJSXptdde05tvvqlffvlFY8eOVV5env1bhSNGjHC4CX7mzJlatmyZfv31V23evFl333239u3bp/vuu0/S+W8YPvzww3ryySe1ZMkSbdu2TSNGjFCzZs00ePDgGukBAABcuqp8D9bLL7+shIQETZkyRQ888IDCwsKMFTV06FAdPXpU06ZNU0ZGhrp06aKlS5fab1Lfv3+//aZ6STpx4oTGjBmjjIwMNWrUSN27d9f69evVoUMH+zaPPvqo8vLydP/99+vkyZPq3bu3li5dWuVHSQAAAJSnygErKipK586dU0pKilJSUlSnTp1S9yzZbDbl5ORUaf7ExEQlJiaWuW716tUOyy+++KJefPHFi85ns9k0c+bMKv3SagAAgMqocsC69dZb7b/sGQAAAP+nygErNTXVYBkAAAC1R5VvcgcAAEDZqnwGq8TBgwe1ZcsW5eTkqLi49BNfR4wYUd23AAAAcCtVDlhnzpzRyJEj9dFHH6m4uFg2m83+iyF/f28WAQsAAFxqqnyJ8PHHH9fHH3+sp556SqtXr5ZlWXrzzTe1bNky+6/K+eGHH0zWCgAA4BaqHLA+/PBDjR49Wo899pg6duwoSWrevLni4+P1r3/9Sw0bNtS8efOMFQoAAOAuqhywsrKyFB0dLUmqW7euJCkvL8++/tZbb9XHH39czfIAAADcT5UDVkhIiI4dOybp/O8mbNSokXbs2GFfn5ubqzNnzlS/QgAAADdT5ZvcY2JilJaWpscee0ySdNNNN+n5559X06ZNVVxcrBdffFFXXnmlsUIBAADcRZXPYE2YMEGRkZE6e/asJOmJJ55Qw4YNdc8992jkyJEKCAjQnDlzjBUKAADgLqp8Bqt3797q3bu3fblFixb65ZdftG3bNnl6eqpdu3aqU6faj9kCAABwO0YTkIeHh6KiokxOCQAA4HaqHLCaNWumuLg4+4tgBQAAcF6VA9agQYOUlpamDz/8UJLk7++vXr16qU+fPoqLi1PPnj3l5eVlrFAAAAB3UeWA9corr0iSTpw4oXXr1mndunVKS0vTtGnTdO7cOfn4+CgmJkarVq0yViwAAIA7qPY9WI0aNdLNN9+sm2++WQcOHNBXX32lWbNm6b///a/Wrl1rokYAAAC3Uq2A9csvv9jPXq1bt04HDhxQQECAYmNjNXr0aMXFxZmqEwAAwG1UOWAFBwfr+PHjatKkieLi4vTXv/7VfrO7zWYzWSMAAIBbqfKDRo8dOyabzaZ27dqpffv2at++vS677DLCFQAAuORV+QzW0aNHlZaWpnXr1mnp0qVKSUmRJHXp0sX+6IbevXsrKCjIWLEAAADuoMoBKzAwUIMGDdKgQYMkSfn5+UpPT9e6dev0/vvva/bs2bLZbDp37pyxYgEAANyBkSe579y5U+vWrdPatWu1bt067dmzR9L5+7QAAAAuNVUOWC+//LLWrl2rtLQ0ZWZmyrIstWrVSnFxcXr88ccVFxenyy+/3GStAAAAbqHKAevhhx/WFVdcoVtvvdV+z1XTpk1N1gYAAOCWqhywjh07poCAAJO1AAAA1ApVfkzD78PVkSNH9MMPPygvL89IUQAAAO6sygFLkj777DO1a9dOYWFh6tatmzZs2CBJys7OVteuXfXpp5+aqBEAAMCtVDlgff7557rlllsUFBSk5ORkWZZlXxcUFKTmzZtr4cKFRooEAABwJ1UOWDNnzlSfPn2Ulpam8ePHl1ofGxurLVu2VKs4AAAAd1TlgPXTTz/pjjvuKHd9SEiIsrKyqjo9AACA26pywPLz87voTe2//vqrAgMDqzo9AACA26pywLrmmmv05ptvlvmrcDIyMvTaa69pwIAB1SoOAADAHVU5YD311FM6ePCgevbsqQULFshms+nrr7/WlClT1KlTJ1mWpeTkZJO1AgAAuIUqB6y2bdsqLS1NgYGBmjp1qizL0vPPP6+nn35anTp10rp16xQREWGwVAAAAPdQrV/23LFjR33zzTc6ceKEdu3apeLiYkVGRtp/ybNlWbLZbEYKBQAAcBfVetBoiUaNGqlnz56KiYlRcHCwCgoK9Oqrr6pt27YmpgcAAHArlT6DVVBQoCVLlmj37t1q1KiRbrzxRjVr1kySlJ+fr5dfflmzZ89WRkaGWrdubbxgAAAAV1epgHX48GH17dtXu3fvtj+5vW7dulqyZIm8vb01bNgwHTp0SNHR0Zo7d65uueWWGikaAADAlVUqYP2///f/tGfPHj366KOKi4vTnj17NHPmTN1///3Kzs5Wx44d9fbbb+vqq6+uqXoBAABcXqUC1vLlyzV69GilpKTYx0JDQ3X77bfrhhtu0GeffSYPDyO3dQEAALitSqWhzMxMXXnllQ5jJct/+ctfCFcAAACqZMAqKiqSr6+vw1jJckBAgLmqAAAA3Filv0W4d+9ebd682b6ck5MjSdq5c6caNmxYavtu3bpVvToAAAA3VOmANXXqVE2dOrXU+Lhx4xyWSx4yWlRUVPXqAAAA3FClAtbChQtrqg4AAIBao1IBa+TIkTVVBwAAQK3B1/4AAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMc8mANW/ePEVERMjX11cxMTHauHFjhfZ77733ZLPZNHjwYIfxzMxMjRo1Ss2aNZOfn5+uu+467dy5swYqBwAAcMGAtXjxYiUlJSk5OVmbN29WVFSUEhISlJWVddH99u7dq4kTJyouLs5h3LIsDR48WL/++qs+++wzbdmyReHh4YqPj1deXl5NtgIAAC5RLhewZs2apTFjxmj06NHq0KGD5s+fLz8/P73xxhvl7lNUVKThw4drxowZioyMdFi3c+dOffvtt3rllVfUs2dPtW3bVq+88op+++03vfvuuzXdDgAAuAS5VMAqKCjQpk2bFB8fbx/z8PBQfHy80tPTy91v5syZatKkie69995S686ePStJ8vX1dZjTx8dHaWlpBqsHAAA4r46zC/i97OxsFRUVKSQkxGE8JCRE27dvL3OftLQ0vf7669q6dWuZ69u1a6eWLVtq8uTJWrBggerVq6cXX3xRBw8e1JEjR8qt5ezZs/ZwJkm5ubmSpMLCQhUWFlays7KVzGNqPldAT+6BnlxfbetHoid3URM91abPp6JcKmBV1qlTp3TPPffotddeU1BQUJnbeHl56eOPP9a9996rxo0by9PTU/Hx8Ro4cKAsyyp37pSUFM2YMaPU+LJly+Tn52esB0lavny50flcAT25B3pyfbWtH4me3IXJnvLz843N5S5cKmAFBQXJ09NTmZmZDuOZmZkKDQ0ttf3u3bu1d+9e3XTTTfax4uJiSVKdOnW0Y8cOtW7dWt27d9fWrVuVk5OjgoICBQcHKyYmRj169Ci3lsmTJyspKcm+nJubqxYtWmjAgAHy9/evbquSzif65cuXq3///vLy8jIyp7PRk3ugJ9dX2/qR6Mld1ERPJVeBLiUuFbC8vb3VvXt3rVixwv6oheLiYq1YsUKJiYmltm/Xrp22bdvmMDZlyhSdOnVKL730klq0aOGwLiAgQNL5G9+///57PfHEE+XW4uPjIx8fn1LjXl5exn+IamJOZ6Mn90BPrq+29SPRk7sw2VNt+2wqwqUCliQlJSVp5MiR6tGjh6KjozV79mzl5eVp9OjRkqQRI0aoefPmSklJka+vr6644gqH/Rs2bChJDuMffPCBgoOD1bJlS23btk0PPfSQBg8erAEDBvxpfQEAgEuHywWsoUOH6ujRo5o2bZoyMjLUpUsXLV261H7j+/79++XhUbkvPx45ckRJSUnKzMxU06ZNNWLECE2dOrUmygcAAHC9gCVJiYmJZV4SlKTVq1dfdN/U1NRSYxMmTNCECRMMVAYAAPDHXOo5WAAAALUBAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGCYSwasefPmKSIiQr6+voqJidHGjRsrtN97770nm82mwYMHO4yfPn1aiYmJCgsLU926ddWhQwfNnz+/BioHAABwwYC1ePFiJSUlKTk5WZs3b1ZUVJQSEhKUlZV10f327t2riRMnKi4urtS6pKQkLV26VG+//bZ++eUXPfzww0pMTNSSJUtqqg0AAHAJc7mANWvWLI0ZM0ajR4+2n2ny8/PTG2+8Ue4+RUVFGj58uGbMmKHIyMhS69evX6+RI0eqb9++ioiI0P3336+oqKgKnxkDAACoDJcKWAUFBdq0aZPi4+PtYx4eHoqPj1d6enq5+82cOVNNmjTRvffeW+b6Xr16acmSJTp06JAsy9KqVav03//+VwMGDDDeAwAAQB1nF/B72dnZKioqUkhIiMN4SEiItm/fXuY+aWlpev3117V169Zy5507d67uv/9+hYWFqU6dOvLw8NBrr72mPn36lLvP2bNndfbsWftybm6uJKmwsFCFhYWV6Kp8JfOYms8V0JN7oCfXV9v6kejJXdRET7Xp86kolwpYlXXq1Cndc889eu211xQUFFTudnPnztW3336rJUuWKDw8XGvXrtX48ePVrFkzh7Nlv5eSkqIZM2aUGl+2bJn8/PyM9SBJy5cvNzqfK6An90BPrq+29SPRk7sw2VN+fr6xudyFzbIsy9lFlCgoKJCfn58+/PBDh28Cjhw5UidPntRnn33msP3WrVvVtWtXeXp62seKi4slnb+0uGPHDjVr1kwBAQH65JNPdMMNN9i3u++++3Tw4EEtXbq0zFrKOoPVokULZWdny9/f30S7Kiws1PLly9W/f395eXkZmdPZ6Mk90JPrq239SPTkLmqip9zcXAUFBSknJ8fYv6GuzqXOYHl7e6t79+5asWKFPWAVFxdrxYoVSkxMLLV9u3bttG3bNoexKVOm6NSpU3rppZfUokULnTlzRoWFhfLwcLzdzNPT0x7GyuLj4yMfH59S415eXsZ/iGpiTmejJ/dAT66vtvUj0ZO7MNlTbftsKsKlApZ0/pEKI0eOVI8ePRQdHa3Zs2crLy9Po0ePliSNGDFCzZs3V0pKinx9fXXFFVc47N+wYUNJso97e3vr6quv1t/+9jfVrVtX4eHhWrNmjf75z39q1qxZf2pvAADg0uByAWvo0KE6evSopk2bpoyMDHXp0kVLly613/i+f//+Umej/sh7772nyZMna/jw4Tp+/LjCw8P11FNP6YEHHqiJFgAAwCXO5QKWJCUmJpZ5SVCSVq9efdF9U1NTS42FhoZq4cKFBioDAAD4Yy71HCwAAIDagIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGEbAAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwAAAADCNgAQAAGFbH2QW4C8uyJEm5ubnG5iwsLFR+fr5yc3Pl5eVlbF5noif3QE+ur7b1I9GTu6iJnkr+7Sz5t/RSQMCqoFOnTkmSWrRo4eRKAABwT6dOnVJAQICzy/hT2KxLKU5WQ3FxsQ4fPqwGDRrIZrMZmTM3N1ctWrTQgQMH5O/vb2ROZ6Mn90BPrq+29SPRk7uoiZ4sy9KpU6fUrFkzeXhcGncncQargjw8PBQWFlYjc/v7+9eaH8wS9OQe6Mn11bZ+JHpyF6Z7ulTOXJW4NGIkAADAn4iABQAAYBgBy4l8fHyUnJwsHx8fZ5diDD25B3pyfbWtH4me3EVt7MkZuMkdAADAMM5gAQAAGEbAAgAAMIyABQAAYBgBCwAAwDAClhPNmzdPERER8vX1VUxMjDZu3Ojskqps+vTpstlsDq927do5u6xKWbt2rW666SY1a9ZMNptNn376qcN6y7I0bdo0NW3aVHXr1lV8fLx27tzpnGIr4I/6GTVqVKljdt111zmn2ApKSUlRz5491aBBAzVp0kSDBw/Wjh07HLY5c+aMxo8fr8DAQNWvX1+33nqrMjMznVTxH6tIT3379i11rB544AEnVXxxr7zyijp37mx/SGVsbKy++uor+3p3Oz7SH/fkTsenPM8884xsNpsefvhh+5g7HitXQsByksWLFyspKUnJycnavHmzoqKilJCQoKysLGeXVmUdO3bUkSNH7K+0tDRnl1QpeXl5ioqK0rx588pc/9xzz2nOnDmaP3++NmzYoHr16ikhIUFnzpz5kyutmD/qR5Kuu+46h2P27rvv/okVVt6aNWs0fvx4ffvtt1q+fLkKCws1YMAA5eXl2bd55JFH9Pnnn+uDDz7QmjVrdPjwYd1yyy1OrPriKtKTJI0ZM8bhWD333HNOqvjiwsLC9Mwzz2jTpk36/vvvde2112rQoEH6+eefJbnf8ZH+uCfJfY5PWb777jstWLBAnTt3dhh3x2PlUiw4RXR0tDV+/Hj7clFRkdWsWTMrJSXFiVVVXXJyshUVFeXsMoyRZH3yySf25eLiYis0NNR6/vnn7WMnT560fHx8rHfffdcJFVbOhf1YlmWNHDnSGjRokFPqMSUrK8uSZK1Zs8ayrPPHxMvLy/rggw/s2/zyyy+WJCs9Pd1ZZVbKhT1ZlmVdffXV1kMPPeS8oqqpUaNG1j/+8Y9acXxKlPRkWe59fE6dOmVddtll1vLlyx36qE3Hylk4g+UEBQUF2rRpk+Lj4+1jHh4eio+PV3p6uhMrq56dO3eqWbNmioyM1PDhw7V//35nl2TMnj17lJGR4XDMAgICFBMT49bHbPXq1WrSpInatm2rsWPH6tixY84uqVJycnIkSY0bN5Ykbdq0SYWFhQ7HqV27dmrZsqXbHKcLeyqxaNEiBQUF6YorrtDkyZOVn5/vjPIqpaioSO+9957y8vIUGxtbK47PhT2VcMfjI0njx4/XDTfc4HBMpNrxs+Rs/LJnJ8jOzlZRUZFCQkIcxkNCQrR9+3YnVVU9MTExSk1NVdu2bXXkyBHNmDFDcXFx+umnn9SgQQNnl1dtGRkZklTmMStZ526uu+463XLLLWrVqpV2796txx9/XAMHDlR6ero8PT2dXd4fKi4u1sMPP6yrrrpKV1xxhaTzx8nb21sNGzZ02NZdjlNZPUnSsGHDFB4ermbNmunHH3/UY489ph07dujjjz92YrXl27Ztm2JjY3XmzBnVr19fn3zyiTp06KCtW7e67fEpryfJ/Y5Piffee0+bN2/Wd999V2qdu/8suQICFowYOHCg/c+dO3dWTEyMwsPD9f777+vee+91YmUoz5133mn/c6dOndS5c2e1bt1aq1evVr9+/ZxYWcWMHz9eP/30k9vd63cx5fV0//332//cqVMnNW3aVP369dPu3bvVunXrP7vMP9S2bVtt3bpVOTk5+vDDDzVy5EitWbPG2WVVS3k9dejQwe2OjyQdOHBADz30kJYvXy5fX19nl1MrcYnQCYKCguTp6Vnq2xiZmZkKDQ11UlVmNWzYUJdffrl27drl7FKMKDkutfmYRUZGKigoyC2OWWJiov71r39p1apVCgsLs4+HhoaqoKBAJ0+edNjeHY5TeT2VJSYmRpJc9lh5e3urTZs26t69u1JSUhQVFaWXXnrJrY9PeT2VxdWPj3T+EmBWVpa6deumOnXqqE6dOlqzZo3mzJmjOnXqKCQkxG2PlasgYDmBt7e3unfvrhUrVtjHiouLtWLFCodr+u7s9OnT2r17t5o2bersUoxo1aqVQkNDHY5Zbm6uNmzYUGuO2cGDB3Xs2DGXPmaWZSkxMVGffPKJVq5cqVatWjms7969u7y8vByO044dO7R//36XPU5/1FNZtm7dKkkufax+r7i4WGfPnnXL41Oekp7K4g7Hp1+/ftq2bZu2bt1qf/Xo0UPDhw+3/7m2HCuncfZd9peq9957z/Lx8bFSU1Ot//znP9b9999vNWzY0MrIyHB2aVXy17/+1Vq9erW1Z88e69///rcVHx9vBQUFWVlZWc4urcJOnTplbdmyxdqyZYslyZo1a5a1ZcsWa9++fZZlWdYzzzxjNWzY0Prss8+sH3/80Ro0aJDVqlUr67fffnNy5WW7WD+nTp2yJk6caKWnp1t79uyxvvnmG6tbt27WZZddZp05c8bZpZdr7NixVkBAgLV69WrryJEj9ld+fr59mwceeMBq2bKltXLlSuv777+3YmNjrdjYWCdWfXF/1NOuXbusmTNnWt9//721Z88e67PPPrMiIyOtPn36OLnysk2aNMlas2aNtWfPHuvHH3+0Jk2aZNlsNmvZsmWWZbnf8bGsi/fkbsfnYi78NqQ7HitXQsByorlz51otW7a0vL29rejoaOvbb791dklVNnToUKtp06aWt7e31bx5c2vo0KHWrl27nF1WpaxatcqSVOo1cuRIy7LOP6ph6tSpVkhIiOXj42P169fP2rFjh3OLvoiL9ZOfn28NGDDACg4Otry8vKzw8HBrzJgxLh/wy+pHkrVw4UL7Nr/99ps1btw4q1GjRpafn581ZMgQ68iRI84r+g/8UU/79++3+vTpYzVu3Njy8fGx2rRpY/3tb3+zcnJynFt4Of7yl79Y4eHhlre3txUcHGz169fPHq4sy/2Oj2VdvCd3Oz4Xc2HAcsdj5UpslmVZf975MgAAgNqPe7AAAAAMI2ABAAAYRsACAAAwjIAFAABgGAELAADAMAIWAACAYQQsAAAAwwhYAAAAhhGwANSY1NRU2Wy2cl/ffvuts0sEgBpRx9kFAKj9Zs6cWeYvMW7Tpo0TqgGAmkfAAlDjBg4cqB49eji1hry8PNWrV8+pNQC4dHCJEIBT7d27VzabTS+88IJeffVVtW7dWj4+PurZs6e+++67Uttv375dt912mxo3bixfX1/16NFDS5Yscdim5NLkmjVrNG7cODVp0kRhYWH29fPmzVNkZKTq1q2r6OhorVu3Tn379lXfvn0lSadPn1a9evX00EMPlXr/gwcPytPTUykpKWY/CAC1CmewANS4nJwcZWdnO4zZbDYFBgbal9955x2dOnVK//M//yObzabnnntOt9xyi3799Vd5eXlJkn7++WddddVVat68uSZNmqR69erp/fff1+DBg/XRRx9pyJAhDu8xbtw4BQcHa9q0acrLy5MkvfLKK0pMTFRcXJweeeQR7d27V4MHD1ajRo3sIax+/foaMmSIFi9erFmzZsnT09M+57vvvivLsjR8+PAa+awA1BIWANSQhQsXWpLKfPn4+FiWZVl79uyxJFmBgYHW8ePH7ft+9tlnliTr888/t4/169fP6tSpk3XmzBn7WHFxsdWrVy/rsssuK/W+vXv3ts6dO2cfP3v2rBUYGGj17NnTKiwstI+npqZakqyrr77aPvb1119bkqyvvvrKoafOnTs7bAcAZeESIYAaN2/ePC1fvtzh9dVXXzlsM3ToUDVq1Mi+HBcXJ0n69ddfJUnHjx/XypUrdccdd+jUqVPKzs5Wdna2jh07poSEBO3cuVOHDh1ymHPMmDEOZ5++//57HTt2TGPGjFGdOv93An/48OEO7y1J8fHxatasmRYtWmQf++mnn/Tjjz/q7rvvruYnAqC24xIhgBoXHR39hze5t2zZ0mG5JPCcOHFCkrRr1y5ZlqWpU6dq6tSpZc6RlZWl5s2b25cv/Obivn37JJX+9mKdOnUUERHhMObh4aHhw4frlVdeUX5+vvz8/LRo0SL5+vrq9ttvv2gvAEDAAuASfn+m6fcsy5IkFRcXS5ImTpyohISEMre9MDjVrVu3WjWNGDFCzz//vD799FPdddddeuedd3TjjTcqICCgWvMCqP0IWADcQmRkpCTJy8tL8fHxVZojPDxc0vmzYddcc419/Ny5c9q7d686d+7ssP0VV1yhrl27atGiRQoLC9P+/fs1d+7cKnYA4FLCPVgA3EKTJk3Ut29fLViwQEeOHCm1/ujRo384R48ePRQYGKjXXntN586ds48vWrTIfinyQvfcc4+WLVum2bNnKzAwUAMHDqx6EwAuGZzBAlDjvvrqK23fvr3UeK9eveThUfH/582bN0+9e/dWp06dNGbMGEVGRiozM1Pp6ek6ePCgfvjhh4vu7+3trenTp+vBBx/UtddeqzvuuEN79+5VamqqWrduLZvNVmqfYcOG6dFHH9Unn3yisWPH2h8ZAQAXQ8ACUOOmTZtW5vjChQvtD/esiA4dOuj777/XjBkzlJqaqmPHjqlJkybq2rVrue9xocTERFmWpf/93//VxIkTFRUVpSVLlmjChAny9fUttX1ISIgGDBigL7/8Uvfcc0+FawVwabNZJXeQAsAlqri4WMHBwbrlllv02muvlVo/ZMgQbdu2Tbt27XJCdQDcEfdgAbiknDlzRhf+v/Kf//ynjh8/XubZtCNHjuiLL77g7BWASuEMFoBLyurVq/XII4/o9ttvV2BgoDZv3qzXX39d7du316ZNm+Tt7S1J2rNnj/7973/rH//4h7777jvt3r1boaGhTq4egLvgHiwAl5SIiAi1aNFCc+bM0fHjx9W4cWONGDFCzzzzjD1cSdKaNWs0evRotWzZUm+++SbhCkClcAYLAADAMO7BAgAAMIyABQAAYBgBCwAAwDACFgAAgGEELAAAAMMIWAAAAIYRsAAAAAwjYAEAABhGwAIAADCMgAUAAGAYAQsAAMAwAhYAAIBhBCwAAADDCFgAAACGEbAAAAAMI2ABAAAYRsACAAAwjIAFAABg2P8HufxaSR0KkwkAAAAASUVORK5CYII=' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -144,14 +144,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 11,
    "id": "64594795-61ee-46f9-b8f0-35325a5e2f56",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "1098668abb05445a8b979a43d36a436b",
+       "model_id": "fd86b1e12b1e490f83b6cae8d565ccdb",
        "version_major": 2,
        "version_minor": 0
       },
@@ -159,25 +159,25 @@
        "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=1.0, min=-1.0, step=0.002…"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "65ba7d4a01e94a599293e403a72dbdec",
+       "model_id": "b01759ddb53740688a4a963e46e3fb38",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -195,14 +195,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 38,
    "id": "10645fdc-831b-4e82-82c3-06066eafb08d",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "123d3df68bb94b53b54f8fab0c84561c",
+       "model_id": "1080f136d8094271867f002e43b76e16",
        "version_major": 2,
        "version_minor": 0
       },
@@ -210,25 +210,25 @@
        "VBox(children=(interactive(children=(FloatSlider(value=0.0, description='alpha', max=1.0, min=-1.0, step=0.002…"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 38,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "a9658f73318845d49f5ab828a9782082",
+       "model_id": "167a9facdff14b5780cca5b8a71543fa",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "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",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=600.0/>\n",
+       "                <img src='data:image/png;base64,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' width=600.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -242,14 +242,12 @@
    ],
    "source": [
     "def delayed_sig(e, a):\n",
-    "    if abs(a) < 0.2:\n",
-    "        return np.ones_like(e)\n",
-    "    elif a > 0:\n",
-    "        return 1.0 / (1.0 + np.exp(-e + 20 * a))\n",
+    "    if a > 0:\n",
+    "        return 1.0 / (1.0 + np.exp(-e + 32 * a))\n",
     "    else:\n",
-    "        return 1.0 / (1.0 + np.exp(e - 20 * (1.0 + a) - 20))\n",
+    "        return 1.0 / (1.0 + np.exp(e - 32 * (1.0 + a) - 16))\n",
     "\n",
-    "sigmoid_reward_widget(delayed_sig)"
+    "sigmoid_reward_widget(delayed_sig, energy_max=80)"
    ]
   },
   {
@@ -370,7 +368,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.6"
   }
  },
  "nbformat": 4,
diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 7258ae9f..59d5695a 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -237,6 +237,7 @@ class DelayedSEReward(RewardFn):
     extractor: Callable[..., tuple[jax.Array, jax.Array]]
     serializer: Callable[[jax.Array, jax.Array, jax.Array], dict[str, jax.Array]]
     delay_scale: float
+    delay_neg_offset: float
 
     def __init__(
         self,
@@ -249,6 +250,7 @@ def __init__(
         std: float = 1.0,
         mean: float = 0.0,
         delay_scale: float = 20.0,
+        delay_neg_offset: float = 20.0,
     ) -> None:
         k1, k2, k3 = jax.random.split(key, 3)
         self.weight = jax.random.normal(k1, (n_agents, n_weights)) * std + mean
@@ -257,6 +259,7 @@ def __init__(
         self.extractor = extractor
         self.serializer = serializer
         self.delay_scale = delay_scale
+        self.delay_neg_offset = delay_neg_offset
 
     def __call__(self, *args) -> jax.Array:
         extracted, energy = self.extractor(*args)
@@ -281,7 +284,9 @@ def __call__(self, *args) -> jax.Array:
         weight = (10**self.scale) * self.weight
         e = energy.reshape(-1, 1)  # (N, n_weights)
         exp_pos = jnp.exp(-e + self.delay_scale * self.delay)
-        exp_neg = jnp.exp(e - self.delay_scale * (1.0 + self.delay) - self.delay_scale)
+        exp_neg = jnp.exp(
+            e - self.delay_scale * (1.0 + self.delay) - self.delay_neg_offset
+        )
         exp = jnp.where(self.delay > 0, exp_pos, exp_neg)
         filtered = extracted / (1.0 + exp)
         return jax.vmap(jnp.dot)(filtered, weight)

From 434faed2c0516c67539196f3db0eeb830da72058 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 7 Mar 2024 15:01:56 +0900
Subject: [PATCH 316/337] poison2

---
 config/env/20240307-ls-poison2.toml | 40 +++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 config/env/20240307-ls-poison2.toml

diff --git a/config/env/20240307-ls-poison2.toml b/config/env/20240307-ls-poison2.toml
new file mode 100644
index 00000000..167a64bd
--- /dev/null
+++ b/config/env/20240307-ls-poison2.toml
@@ -0,0 +1,40 @@
+n_initial_agents = 50
+n_max_agents = 150
+n_max_foods = 100
+n_food_sources = 2
+food_num_fn = [
+    ["logistic", 20, 0.01, 60],
+    ["logistic", 10, 0.01, 40],
+]
+food_loc_fn = [
+   ["gaussian", [360.0, 270.0], [48.0, 36.0]],
+   ["gaussian", [120.0, 270.0], [48.0, 36.0]],
+]
+food_color = [[254, 2, 162, 255], [2, 254, 162, 255]]
+food_energy_coef = [1.0, -0.2]
+agent_loc_fn = "uniform"
+observe_food_label = true
+xlim = [0.0, 480.0]
+ylim = [0.0, 360.0]
+env_shape = "square"
+neighbor_stddev = 100.0
+n_agent_sensors = 24
+sensor_length = 200.0
+sensor_range = "wide"
+agent_radius = 10.0
+food_radius = 4.0
+foodloc_interval = 1000
+dt = 0.1
+linear_damping = 0.8
+angular_damping = 0.6
+max_force = 80.0
+min_force = -20.0
+init_energy = 40.0
+energy_capacity = 400.0
+force_energy_consumption = 2e-5
+basic_energy_consumption = 2e-4
+energy_share_ratio = 0.4
+n_velocity_iter = 6
+n_position_iter = 2
+n_physics_iter = 5
+max_place_attempts = 10
\ No newline at end of file

From 6c74d1f8065be694e0e6d62ca464afd5eb900c9d Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 7 Mar 2024 15:24:36 +0900
Subject: [PATCH 317/337] Fix offsetdelayedsbe

---
 src/emevo/reward_fn.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/emevo/reward_fn.py b/src/emevo/reward_fn.py
index 59d5695a..4d883f51 100644
--- a/src/emevo/reward_fn.py
+++ b/src/emevo/reward_fn.py
@@ -299,7 +299,9 @@ def __call__(self, *args) -> jax.Array:
         weight = (10**scale) * self.weight
         e = energy.reshape(-1, 1)  # (N, n_weights)
         exp_pos = jnp.exp(-e + self.delay_scale * self.delay)
-        exp_neg = jnp.exp(e - self.delay_scale * (1.0 + self.delay) - self.delay_scale)
+        exp_neg = jnp.exp(
+            e - self.delay_scale * (1.0 + self.delay) - self.delay_neg_offset
+        )
         exp = jnp.where(self.delay > 0, exp_pos, exp_neg)
         filtered = extracted / (1.0 + exp)
         return jax.vmap(jnp.dot)(filtered, weight)

From a25c1dcbf5eca5ef3692308e9ff740c2ffcbd49a Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 7 Mar 2024 19:16:57 +0900
Subject: [PATCH 318/337] We don't need log_offset anymore

---
 experiments/cf_asexual_evo.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 470d9f12..69c80dc5 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -736,7 +736,6 @@ def widget(
     start: int = 0,
     end: Optional[int] = None,
     cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
-    log_offset: int = 0,
     log_path: Optional[Path] = None,
     self_terminate: bool = False,
     profile_and_rewards_path: Optional[Path] = None,
@@ -760,8 +759,7 @@ def widget(
         import pyarrow.dataset as ds
 
         log_ds = ds.dataset(log_path)
-        first_step = log_ds.scanner(columns=["step"]).head(1)["step"][0].as_py()
-        step_offset = first_step + log_offset
+        step_offset = log_ds.scanner(columns=["step"]).head(1)["step"][0].as_py()
 
     if profile_and_rewards_path is None:
         profile_and_rewards = None

From d7ad21b1f3b3efa999ecc35104def7af6d5a22bc Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 7 Mar 2024 21:51:18 +0900
Subject: [PATCH 319/337] Tweak on widget

---
 src/emevo/analysis/qt_widget.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/emevo/analysis/qt_widget.py b/src/emevo/analysis/qt_widget.py
index 7a08d7df..e9c3f572 100644
--- a/src/emevo/analysis/qt_widget.py
+++ b/src/emevo/analysis/qt_widget.py
@@ -405,6 +405,7 @@ def __init__(
         self._mgl_widget.selectionChanged.connect(self.updateRewards)
         self._mgl_widget.stepChanged.connect(self.updateStep)
         self._slider.sliderMoved.connect(self._mgl_widget.sliderChanged)
+        self._slider.sliderMoved.connect(self.updateSliderLabel)
         if profile_and_rewards is not None:
             self.rewardUpdated.connect(self._reward_widget.updateValues)
         # Initial size
@@ -521,6 +522,10 @@ def updateStep(self, step_index: int) -> None:
         self._slider.setValue(step)
         self._slider_label.setText(f"Step {step}")
 
+    @Slot(int)
+    def updateSliderLabel(self, slider_value: int) -> None:
+        self._slider_label.setText(f"Step {slider_value}")
+
     @Slot(int, int)
     def updateRewards(self, selected_slot: int, step_index: int) -> None:
         if self._profile_and_rewards is None or selected_slot == -1:

From bd0ef2e8df2c0235de617ac7b82171db947da0f9 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 8 Mar 2024 16:50:57 +0900
Subject: [PATCH 320/337] Typo

---
 src/emevo/exp_utils.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 88a2311c..0f7fd63b 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -212,6 +212,8 @@ def load(path: Path) -> Self:
         # For backward compatibility
         if "static_circle_label" in npzfile:
             static_circle_label = jnp.array(npzfile["static_circle_label"])
+        elif "static_cirlce_label" in npzfile:  # Support typo version
+            static_circle_label = jnp.array(npzfile["static_cirlce_label"])
         else:
             static_circle_label = jnp.zeros(static_circle_is_active.shape[0], dtype=jnp.uint8)
         return SavedPhysicsState(
@@ -251,7 +253,7 @@ def save_physstates(phys_states: list[SavedPhysicsState], path: Path) -> None:
         circle_is_active=concatenated.circle_is_active,
         static_circle_axy=concatenated.static_circle_axy,
         static_circle_is_active=concatenated.static_circle_is_active,
-        static_cirlce_label=concatenated.static_circle_label,
+        static_circle_label=concatenated.static_circle_label,
     )
 
 

From 9d9bef72fe9b555c4a2a9adce133600efb78fb50 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 8 Mar 2024 18:21:11 +0900
Subject: [PATCH 321/337] Poison LV

---
 config/env/20240303-poison-lv.toml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/config/env/20240303-poison-lv.toml b/config/env/20240303-poison-lv.toml
index efcf65e7..d498e273 100644
--- a/config/env/20240303-poison-lv.toml
+++ b/config/env/20240303-poison-lv.toml
@@ -1,17 +1,17 @@
 n_initial_agents = 50
 n_max_agents = 150
-n_max_foods = 90
+n_max_foods = 100
 n_food_sources = 2
 food_num_fn = [
-    ["logistic", 20, 0.01, 70],
-    ["logistic", 10, 0.01, 20],
+    ["logistic", 20, 0.01, 60],
+    ["logistic", 10, 0.01, 40],
 ]
 food_loc_fn = [
    ["gaussian", [360.0, 270.0], [80.0, 60.0]],
-   ["gaussian", [360.0, 90.0], [80.0, 60.0]],
+   ["gaussian", [120.0, 270.0], [80.0, 60.0]],
 ]
 food_color = [[254, 2, 162, 255], [2, 254, 162, 255]]
-food_energy_coef = [1.0, -0.1]
+food_energy_coef = [1.0, -0.2]
 agent_loc_fn = "uniform"
 observe_food_label = true
 xlim = [0.0, 480.0]

From 192a1d4685663b562986a97df725a2df0fe472f4 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 11 Mar 2024 17:42:27 +0900
Subject: [PATCH 322/337] Don't save age

---
 experiments/cf_asexual_evo.py |  1 -
 src/emevo/exp_utils.py        | 23 ++++++++++++++---------
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 69c80dc5..8313e30f 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -306,7 +306,6 @@ def step_rollout(
             got_food=obs_t1.collision[:, 1],
             parents=parents,
             rewards=rewards.ravel(),
-            age=state_t1db.status.age,
             energy=state_t1db.status.energy,
             unique_id=state_t1db.unique_id.unique_id,
         )
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 0f7fd63b..15832c49 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -146,7 +146,6 @@ class Log:
     got_food: jax.Array
     parents: jax.Array
     rewards: jax.Array
-    age: jax.Array
     energy: jax.Array
     unique_id: jax.Array
 
@@ -197,6 +196,9 @@ class SavedProfile:
     unique_id: int
 
 
+_XY_SAVE_DTYPE = np.float16
+
+
 @chex.dataclass
 class SavedPhysicsState:
     circle_axy: jax.Array
@@ -208,18 +210,21 @@ class SavedPhysicsState:
     @staticmethod
     def load(path: Path) -> Self:
         npzfile = np.load(path)
-        static_circle_is_active=jnp.array(npzfile["static_circle_is_active"])
+        static_circle_is_active = jnp.array(npzfile["static_circle_is_active"])
         # For backward compatibility
         if "static_circle_label" in npzfile:
             static_circle_label = jnp.array(npzfile["static_circle_label"])
-        elif "static_cirlce_label" in npzfile:  # Support typo version
-            static_circle_label = jnp.array(npzfile["static_cirlce_label"])
         else:
-            static_circle_label = jnp.zeros(static_circle_is_active.shape[0], dtype=jnp.uint8)
+            static_circle_label = jnp.zeros(
+                static_circle_is_active.shape[0],
+                dtype=jnp.uint8,
+            )
         return SavedPhysicsState(
-            circle_axy=jnp.array(npzfile["circle_axy"]),
+            circle_axy=jnp.array(npzfile["circle_axy"].astype(np.float32)),
             circle_is_active=jnp.array(npzfile["circle_is_active"]),
-            static_circle_axy=jnp.array(npzfile["static_circle_axy"]),
+            static_circle_axy=jnp.array(
+                npzfile["static_circle_axy"].astype(np.float32)
+            ),
             static_circle_is_active=static_circle_is_active,
             static_circle_label=static_circle_label,
         )
@@ -249,9 +254,9 @@ def save_physstates(phys_states: list[SavedPhysicsState], path: Path) -> None:
     concatenated = jax.tree_map(lambda *args: np.concatenate(args), *phys_states)
     np.savez_compressed(
         path,
-        circle_axy=concatenated.circle_axy,
+        circle_axy=concatenated.circle_axy.astype(_XY_SAVE_DTYPE),
         circle_is_active=concatenated.circle_is_active,
-        static_circle_axy=concatenated.static_circle_axy,
+        static_circle_axy=concatenated.static_circle_axy.astype(_XY_SAVE_DTYPE),
         static_circle_is_active=concatenated.static_circle_is_active,
         static_circle_label=concatenated.static_circle_label,
     )

From 94b9ce522bd02339ed5d60709f9df83d210df3c9 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 12 Mar 2024 17:14:17 +0900
Subject: [PATCH 323/337] Simplify file names

---
 experiments/cfs_as_evo.py => cf_smell.py |   0
 experiments/cf_simple.py                 | 792 +++++++++++++++++++++++
 2 files changed, 792 insertions(+)
 rename experiments/cfs_as_evo.py => cf_smell.py (100%)
 create mode 100644 experiments/cf_simple.py

diff --git a/experiments/cfs_as_evo.py b/cf_smell.py
similarity index 100%
rename from experiments/cfs_as_evo.py
rename to cf_smell.py
diff --git a/experiments/cf_simple.py b/experiments/cf_simple.py
new file mode 100644
index 00000000..47043c3c
--- /dev/null
+++ b/experiments/cf_simple.py
@@ -0,0 +1,792 @@
+"""Asexual reward evolution with Circle Foraging"""
+import dataclasses
+import enum
+import json
+from pathlib import Path
+from typing import Optional, cast
+
+import chex
+import equinox as eqx
+import jax
+import jax.numpy as jnp
+import numpy as np
+import optax
+import typer
+from serde import toml
+
+from emevo import Env
+from emevo import birth_and_death as bd
+from emevo import genetic_ops as gops
+from emevo import make
+from emevo import reward_fn as rfn
+from emevo.env import ObsProtocol as Obs
+from emevo.env import StateProtocol as State
+from emevo.eqx_utils import get_slice
+from emevo.eqx_utils import where as eqx_where
+from emevo.exp_utils import (
+    BDConfig,
+    CfConfig,
+    GopsConfig,
+    Log,
+    Logger,
+    LogMode,
+    SavedPhysicsState,
+    SavedProfile,
+)
+from emevo.rl.ppo_normal import (
+    NormalPPONet,
+    Rollout,
+    vmap_apply,
+    vmap_batch,
+    vmap_net,
+    vmap_update,
+    vmap_value,
+)
+from emevo.spaces import BoxSpace
+from emevo.visualizer import SaveVideoWrapper
+
+PROJECT_ROOT = Path(__file__).parent.parent
+
+
+class RewardKind(str, enum.Enum):
+    BOUNDED_EXP = "bounded-exp"
+    DELAYED_SE = "delayed-se"
+    LINEAR = "linear"
+    EXPONENTIAL = "exponential"
+    OFFSET_DELAYED_SBE = "offset-delayed-sbe"
+    OFFSET_DELAYED_SE = "offset-delayed-se"
+    OFFSET_DELAYED_SINH = "offset-delayed-sinh"
+    SIGMOID = "sigmoid"
+    SIGMOID_01 = "sigmoid-01"
+    SIGMOID_EXP = "sigmoid-exp"
+    SINH = "sinh"
+
+
+@dataclasses.dataclass
+class RewardExtractor:
+    act_space: BoxSpace
+    act_coef: float
+    mask: dataclasses.InitVar[str] = "1111"
+    _mask_array: jax.Array = dataclasses.field(init=False)
+    _max_norm: jax.Array = dataclasses.field(init=False)
+
+    def __post_init__(self, mask: str) -> None:
+        mask_array = jnp.array([x == "1" for x in mask])
+        self._mask_array = jnp.expand_dims(mask_array, axis=0)
+        self._max_norm = jnp.sqrt(
+            jnp.sum(self.act_space.high**2, axis=-1, keepdims=True)
+        )
+
+    def normalize_action(self, action: jax.Array) -> jax.Array:
+        scaled = self.act_space.sigmoid_scale(action)
+        norm = jnp.sqrt(jnp.sum(scaled**2, axis=-1, keepdims=True))
+        return norm / self._max_norm
+
+    def extract_linear(
+        self,
+        collision: jax.Array,
+        action: jax.Array,
+        energy: jax.Array,
+    ) -> jax.Array:
+        del energy
+        act_input = self.act_coef * self.normalize_action(action)
+        return jnp.concatenate((collision, act_input), axis=1) * self._mask_array
+
+    def extract_sigmoid(
+        self,
+        collision: jax.Array,
+        action: jax.Array,
+        energy: jax.Array,
+    ) -> tuple[jax.Array, jax.Array]:
+        act_input = self.act_coef * self.normalize_action(action)
+        reward_input = jnp.concatenate((collision, act_input), axis=1)
+        return reward_input * self._mask_array, energy
+
+
+def linear_rs(w: jax.Array) -> dict[str, jax.Array]:
+    return rfn.serialize_weight(w, ["food", "action"])
+
+
+def exp_rs(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(w, ["w_food", "w_action"])
+    scale_dict = rfn.serialize_weight(
+        scale,
+        ["scale_agent", "scale_food", "scale_wall", "scale_action"],
+    )
+    return w_dict | scale_dict
+
+
+def sigmoid_rs(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    alpha_dict = rfn.serialize_weight(
+        alpha,
+        ["alpha_agent", "alpha_food", "alpha_wall", "alpha_action"],
+    )
+    return w_dict | alpha_dict
+
+
+def delayed_sigmoid_rs(w: jax.Array, delay: jax.Array) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    delay_dict = rfn.serialize_weight(
+        delay,
+        ["delay_agent", "delay_food", "delay_wall", "delay_action"],
+    )
+    return w_dict | delay_dict
+
+
+def sigmoid_exp_rs(
+    w: jax.Array,
+    scale: jax.Array,
+    alpha: jax.Array,
+) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    alpha_dict = rfn.serialize_weight(
+        alpha,
+        ["alpha_agent", "alpha_food", "alpha_wall", "alpha_action"],
+    )
+    scale_dict = rfn.serialize_weight(
+        scale,
+        ["scale_agent", "scale_food", "scale_wall", "scale_action"],
+    )
+    return (w_dict | alpha_dict) | scale_dict
+
+
+def delayed_se_rs(
+    w: jax.Array,
+    scale: jax.Array,
+    delay: jax.Array,
+) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
+    delay_dict = rfn.serialize_weight(
+        delay,
+        ["delay_agent", "delay_food", "delay_wall", "delay_action"],
+    )
+    scale_dict = rfn.serialize_weight(
+        scale,
+        ["scale_agent", "scale_food", "scale_wall", "scale_action"],
+    )
+    return (w_dict | delay_dict) | scale_dict
+
+
+def linear_rs_withp(w: jax.Array) -> dict[str, jax.Array]:
+    return rfn.serialize_weight(w, ["agent", "food", "poison", "wall", "action"])
+
+
+def exp_rs_withp(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(
+        w,
+        ["w_agent", "w_food", "w_poison", "w_wall", "w_action"],
+    )
+    scale_dict = rfn.serialize_weight(
+        scale,
+        ["scale_agent", "scale_food", "scale_poison", "scale_wall", "scale_action"],
+    )
+    return w_dict | scale_dict
+
+
+def sigmoid_rs_withp(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(
+        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
+    )
+    alpha_dict = rfn.serialize_weight(
+        alpha,
+        ["alpha_agent", "alpha_food", "alpha_poison", "alpha_wall", "alpha_action"],
+    )
+    return w_dict | alpha_dict
+
+
+def delayed_sigmoid_rs_withp(w: jax.Array, delay: jax.Array) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(
+        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
+    )
+    threshold_dict = rfn.serialize_weight(
+        delay,
+        [
+            "threshold_agent",
+            "threshold_food",
+            "threshold_poison",
+            "threshold_wall",
+            "threshold_action",
+        ],
+    )
+    return w_dict | threshold_dict
+
+
+def sigmoid_exp_rs_withp(
+    w: jax.Array, scale: jax.Array, alpha: jax.Array
+) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(
+        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
+    )
+    alpha_dict = rfn.serialize_weight(
+        alpha,
+        ["alpha_agent", "alpha_food", "alpha_poison", "alpha_wall", "alpha_action"],
+    )
+    scale_dict = rfn.serialize_weight(
+        scale,
+        ["scale_agent", "scale_food", "scale_poison", "scale_wall", "scale_action"],
+    )
+    return (w_dict | alpha_dict) | scale_dict
+
+
+def delayed_se_rs_withp(
+    w: jax.Array, scale: jax.Array, delay: jax.Array
+) -> dict[str, jax.Array]:
+    w_dict = rfn.serialize_weight(
+        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
+    )
+    threshold_dict = rfn.serialize_weight(
+        delay,
+        [
+            "threshold_agent",
+            "threshold_food",
+            "threshold_poison",
+            "threshold_wall",
+            "threshold_action",
+        ],
+    )
+    scale_dict = rfn.serialize_weight(
+        scale,
+        ["scale_agent", "scale_food", "scale_poison", "scale_wall", "scale_action"],
+    )
+    return (w_dict | threshold_dict) | scale_dict
+
+
+def exec_rollout(
+    state: State,
+    initial_obs: Obs,
+    env: Env,
+    network: NormalPPONet,
+    reward_fn: rfn.RewardFn,
+    hazard_fn: bd.HazardFunction,
+    birth_fn: bd.BirthFunction,
+    prng_key: jax.Array,
+    n_rollout_steps: int,
+) -> tuple[State, Rollout, Log, SavedPhysicsState, Obs, jax.Array]:
+    def step_rollout(
+        carried: tuple[State, Obs],
+        key: jax.Array,
+    ) -> tuple[tuple[State, Obs], tuple[Rollout, Log, SavedPhysicsState]]:
+        act_key, hazard_key, birth_key = jax.random.split(key, 3)
+        state_t, obs_t = carried
+        obs_t_array = obs_t.as_array()
+        net_out = vmap_apply(network, obs_t_array)
+        actions = net_out.policy().sample(seed=act_key)
+        state_t1, timestep = env.step(
+            state_t,
+            env.act_space.sigmoid_scale(actions),  # type: ignore
+        )
+        obs_t1 = timestep.obs
+        energy = state_t.status.energy
+        rewards = reward_fn(obs_t1.collision, actions, energy).reshape(-1, 1)
+        rollout = Rollout(
+            observations=obs_t_array,
+            actions=actions,
+            rewards=rewards,
+            terminations=jnp.zeros_like(rewards),
+            values=net_out.value,
+            means=net_out.mean,
+            logstds=net_out.logstd,
+        )
+        # Birth and death
+        death_prob = hazard_fn(state_t1.status.age, state_t1.status.energy)
+        dead = jax.random.bernoulli(hazard_key, p=death_prob)
+        state_t1d = env.deactivate(state_t1, dead)
+        birth_prob = birth_fn(state_t1d.status.age, state_t1d.status.energy)
+        possible_parents = jnp.logical_and(
+            jnp.logical_and(
+                jnp.logical_not(dead),
+                state.unique_id.is_active(),  # type: ignore
+            ),
+            jax.random.bernoulli(birth_key, p=birth_prob),
+        )
+        state_t1db, parents = env.activate(state_t1d, possible_parents)
+        log = Log(
+            dead=jnp.where(dead, state_t.unique_id.unique_id, -1),  # type: ignore
+            got_food=obs_t1.collision[:, 1],
+            parents=parents,
+            rewards=rewards.ravel(),
+            energy=state_t1db.status.energy,
+            unique_id=state_t1db.unique_id.unique_id,
+        )
+        phys = state_t.physics  # type: ignore
+        phys_state = SavedPhysicsState(
+            circle_axy=phys.circle.p.into_axy(),
+            static_circle_axy=phys.static_circle.p.into_axy(),
+            circle_is_active=phys.circle.is_active,
+            static_circle_is_active=phys.static_circle.is_active,
+            static_circle_label=phys.static_circle.label,
+        )
+        return (state_t1db, obs_t1), (rollout, log, phys_state)
+
+    (state, obs), (rollout, log, phys_state) = jax.lax.scan(
+        step_rollout,
+        (state, initial_obs),
+        jax.random.split(prng_key, n_rollout_steps),
+    )
+    next_value = vmap_value(network, obs.as_array())
+    return state, rollout, log, phys_state, obs, next_value
+
+
+@eqx.filter_jit
+def epoch(
+    state: State,
+    initial_obs: Obs,
+    env: Env,
+    network: NormalPPONet,
+    reward_fn: rfn.RewardFn,
+    hazard_fn: bd.HazardFunction,
+    birth_fn: bd.BirthFunction,
+    prng_key: jax.Array,
+    n_rollout_steps: int,
+    gamma: float,
+    gae_lambda: float,
+    adam_update: optax.TransformUpdateFn,
+    opt_state: optax.OptState,
+    minibatch_size: int,
+    n_optim_epochs: int,
+) -> tuple[State, Obs, Log, SavedPhysicsState, optax.OptState, NormalPPONet]:
+    keys = jax.random.split(prng_key, env.n_max_agents + 1)
+    env_state, rollout, log, phys_state, obs, next_value = exec_rollout(
+        state,
+        initial_obs,
+        env,
+        network,
+        reward_fn,
+        hazard_fn,
+        birth_fn,
+        keys[0],
+        n_rollout_steps,
+    )
+    batch = vmap_batch(rollout, next_value, gamma, gae_lambda)
+    opt_state, pponet = vmap_update(
+        batch,
+        network,
+        adam_update,
+        opt_state,
+        keys[1:],
+        minibatch_size,
+        n_optim_epochs,
+        0.2,
+        0.0,
+    )
+    return env_state, obs, log, phys_state, opt_state, pponet
+
+
+def run_evolution(
+    *,
+    key: jax.Array,
+    env: Env,
+    n_initial_agents: int,
+    adam: optax.GradientTransformation,
+    gamma: float,
+    gae_lambda: float,
+    n_optim_epochs: int,
+    minibatch_size: int,
+    n_rollout_steps: int,
+    n_total_steps: int,
+    reward_fn: rfn.RewardFn,
+    hazard_fn: bd.HazardFunction,
+    birth_fn: bd.BirthFunction,
+    mutation: gops.Mutation,
+    xmax: float,
+    ymax: float,
+    logger: Logger,
+    debug_vis: bool,
+) -> None:
+    key, net_key, reset_key = jax.random.split(key, 3)
+    obs_space = env.obs_space.flatten()
+    input_size = np.prod(obs_space.shape)
+    act_size = np.prod(env.act_space.shape)
+
+    def initialize_net(key: chex.PRNGKey) -> NormalPPONet:
+        return vmap_net(
+            input_size,
+            64,
+            act_size,
+            jax.random.split(key, env.n_max_agents),
+        )
+
+    pponet = initialize_net(net_key)
+    adam_init, adam_update = adam
+
+    @eqx.filter_jit
+    def initialize_opt_state(net: eqx.Module) -> optax.OptState:
+        return jax.vmap(adam_init)(eqx.filter(net, eqx.is_array))
+
+    @eqx.filter_jit
+    def replace_net(
+        key: chex.PRNGKey,
+        flag: jax.Array,
+        pponet: NormalPPONet,
+        opt_state: optax.OptState,
+    ) -> tuple[NormalPPONet, optax.OptState]:
+        initialized = initialize_net(key)
+        pponet = eqx_where(flag, initialized, pponet)
+        opt_state = jax.tree_map(
+            lambda a, b: jnp.where(
+                jnp.expand_dims(flag, tuple(range(1, a.ndim))),
+                b,
+                a,
+            ),
+            opt_state,
+            initialize_opt_state(pponet),
+        )
+        return pponet, opt_state
+
+    opt_state = initialize_opt_state(pponet)
+    env_state, timestep = env.reset(reset_key)
+    obs = timestep.obs
+
+    if debug_vis:
+        visualizer = env.visualizer(env_state, figsize=(xmax * 2, ymax * 2))
+    else:
+        visualizer = None
+
+    for i in range(n_initial_agents):
+        logger.reward_fn_dict[i + 1] = get_slice(reward_fn, i)
+        logger.profile_dict[i + 1] = SavedProfile(0, 0, i + 1)
+
+    for i, key in enumerate(jax.random.split(key, n_total_steps // n_rollout_steps)):
+        epoch_key, init_key = jax.random.split(key)
+        env_state, obs, log, phys_state, opt_state, pponet = epoch(
+            env_state,
+            obs,
+            env,
+            pponet,
+            reward_fn,
+            hazard_fn,
+            birth_fn,
+            epoch_key,
+            n_rollout_steps,
+            gamma,
+            gae_lambda,
+            adam_update,
+            opt_state,
+            minibatch_size,
+            n_optim_epochs,
+        )
+
+        if visualizer is not None:
+            visualizer.render(env_state.physics)  # type: ignore
+            visualizer.show()
+        # Extinct?
+        n_active = jnp.sum(env_state.unique_id.is_active())  # type: ignore
+        if n_active == 0:
+            print(f"Extinct after {i + 1} epochs")
+            break
+
+        # Save network
+        log_with_step = log.with_step(i * n_rollout_steps)
+        log_death = log_with_step.filter_death()
+        logger.save_agents(pponet, log_death.dead, log_death.slots)
+        log_birth = log_with_step.filter_birth()
+        # Initialize network and adam state for new agents
+        is_new = jnp.zeros(env.n_max_agents, dtype=bool).at[log_birth.slots].set(True)
+        if jnp.any(is_new):
+            pponet, opt_state = replace_net(init_key, is_new, pponet, opt_state)
+
+        # Mutation
+        reward_fn = rfn.mutate_reward_fn(
+            key,
+            logger.reward_fn_dict,
+            reward_fn,
+            mutation,
+            log_birth.parents,
+            log_birth.unique_id,
+            log_birth.slots,
+        )
+        # Update profile
+        for step, uid, parent in zip(
+            log_birth.step,
+            log_birth.unique_id,
+            log_birth.parents,
+        ):
+            ui = uid.item()
+            logger.profile_dict[ui] = SavedProfile(step.item(), parent.item(), ui)
+
+        # Push log and physics state
+        logger.push_log(log_with_step.filter_active())
+        logger.push_physstate(phys_state)
+
+    # Save logs before exiting
+    logger.finalize()
+    is_active = env_state.unique_id.is_active()
+    logger.save_agents(
+        pponet,
+        env_state.unique_id.unique_id[is_active],
+        jnp.arange(len(is_active))[is_active],
+    )
+
+
+app = typer.Typer(pretty_exceptions_show_locals=False)
+
+
+@app.command()
+def evolve(
+    seed: int = 1,
+    n_agents: int = 20,
+    init_energy: float = 20.0,
+    action_cost: float = 0.0001,
+    mutation_prob: float = 0.2,
+    adam_lr: float = 3e-4,
+    adam_eps: float = 1e-7,
+    gamma: float = 0.999,
+    gae_lambda: float = 0.95,
+    n_optim_epochs: int = 10,
+    minibatch_size: int = 256,
+    n_rollout_steps: int = 1024,
+    n_total_steps: int = 1024 * 10000,
+    act_reward_coef: float = 0.001,
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
+    bdconfig_path: Path = PROJECT_ROOT / "config/bd/20230530-a035-e020.toml",
+    gopsconfig_path: Path = PROJECT_ROOT / "config/gops/20240111-mutation-0401.toml",
+    env_override: str = "",
+    birth_override: str = "",
+    hazard_override: str = "",
+    reward_mask: Optional[str] = None,
+    reward_fn: RewardKind = RewardKind.LINEAR,
+    logdir: Path = Path("./log"),
+    log_mode: LogMode = LogMode.FULL,
+    log_interval: int = 1000,
+    savestate_interval: int = 1000,
+    poison_reward: bool = False,
+    debug_vis: bool = False,
+) -> None:
+    # Load config
+    with cfconfig_path.open("r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+    with bdconfig_path.open("r") as f:
+        bdconfig = toml.from_toml(BDConfig, f.read())
+    with gopsconfig_path.open("r") as f:
+        gopsconfig = toml.from_toml(GopsConfig, f.read())
+
+    # Apply overrides
+    cfconfig.apply_override(env_override)
+    bdconfig.apply_birth_override(birth_override)
+    bdconfig.apply_hazard_override(hazard_override)
+
+    if reward_mask is None:
+        if poison_reward:
+            reward_mask = "11111"
+        else:
+            reward_mask = "1111"
+
+    # Load models
+    birth_fn, hazard_fn = bdconfig.load_models()
+    mutation = gopsconfig.load_model()
+    # Override config
+    cfconfig.n_initial_agents = n_agents
+    cfconfig.init_energy = init_energy
+    cfconfig.force_energy_consumption = action_cost
+    gopsconfig.params["mutation_prob"] = mutation_prob
+    # Make env
+    env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
+    key, reward_key = jax.random.split(jax.random.PRNGKey(seed))
+    reward_extracor = RewardExtractor(
+        act_space=env.act_space,  # type: ignore
+        act_coef=act_reward_coef,
+        mask=reward_mask,
+    )
+    common_rewardfn_args = {
+        "key": reward_key,
+        "n_agents": cfconfig.n_max_agents,
+        "n_weights": 5 if poison_reward else 4,
+        "std": gopsconfig.init_std,
+        "mean": gopsconfig.init_mean,
+    }
+    common_rewardfn_args |= gopsconfig.init_kwargs
+    if reward_fn == RewardKind.LINEAR:
+        reward_fn_instance = rfn.LinearReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_linear,
+            serializer=linear_rs_withp if poison_reward else linear_rs,
+        )
+    elif reward_fn == RewardKind.EXPONENTIAL:
+        reward_fn_instance = rfn.ExponentialReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_linear,
+            serializer=exp_rs_withp if poison_reward else exp_rs,
+        )
+    elif reward_fn == RewardKind.BOUNDED_EXP:
+        reward_fn_instance = rfn.BoundedExponentialReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_linear,
+            serializer=exp_rs_withp if poison_reward else exp_rs,
+        )
+    elif reward_fn == RewardKind.SIGMOID:
+        reward_fn_instance = rfn.SigmoidReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=sigmoid_rs_withp if poison_reward else sigmoid_rs,
+        )
+    elif reward_fn == RewardKind.SIGMOID_01:
+        reward_fn_instance = rfn.SigmoidReward_01(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=sigmoid_rs_withp if poison_reward else sigmoid_rs,
+        )
+    elif reward_fn == RewardKind.SIGMOID_EXP:
+        reward_fn_instance = rfn.SigmoidExponentialReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=sigmoid_exp_rs_withp if poison_reward else sigmoid_exp_rs,
+        )
+    elif reward_fn == RewardKind.DELAYED_SE:
+        reward_fn_instance = rfn.DelayedSEReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=delayed_se_rs_withp if poison_reward else delayed_se_rs,
+        )
+    elif reward_fn == RewardKind.OFFSET_DELAYED_SBE:
+        reward_fn_instance = rfn.OffsetDelayedSBEReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=delayed_se_rs_withp if poison_reward else delayed_se_rs,
+        )
+    elif reward_fn == RewardKind.OFFSET_DELAYED_SE:
+        reward_fn_instance = rfn.OffsetDelayedSEReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=delayed_se_rs_withp if poison_reward else delayed_se_rs,
+        )
+    elif reward_fn == RewardKind.SINH:
+        reward_fn_instance = rfn.SinhReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_linear,
+            serializer=linear_rs_withp if poison_reward else linear_rs,
+        )
+    elif reward_fn == RewardKind.OFFSET_DELAYED_SINH:
+        reward_fn_instance = rfn.OffsetDelayedSinhReward(
+            **common_rewardfn_args,
+            extractor=reward_extracor.extract_sigmoid,
+            serializer=delayed_sigmoid_rs_withp
+            if poison_reward
+            else delayed_sigmoid_rs,
+        )
+    else:
+        raise ValueError(f"Invalid reward_fn {reward_fn}")
+
+    logger = Logger(
+        logdir=logdir,
+        mode=log_mode,
+        log_interval=log_interval,
+        savestate_interval=savestate_interval,
+    )
+    run_evolution(
+        key=key,
+        env=env,
+        n_initial_agents=n_agents,
+        adam=optax.adam(adam_lr, eps=adam_eps),
+        gamma=gamma,
+        gae_lambda=gae_lambda,
+        n_optim_epochs=n_optim_epochs,
+        minibatch_size=minibatch_size,
+        n_rollout_steps=n_rollout_steps,
+        n_total_steps=n_total_steps,
+        reward_fn=reward_fn_instance,
+        hazard_fn=hazard_fn,
+        birth_fn=birth_fn,
+        mutation=cast(gops.Mutation, mutation),
+        xmax=cfconfig.xlim[1],
+        ymax=cfconfig.ylim[1],
+        logger=logger,
+        debug_vis=debug_vis,
+    )
+
+
+@app.command()
+def replay(
+    physstate_path: Path,
+    backend: str = "pyglet",  # Use "headless" for headless rendering
+    videopath: Optional[Path] = None,
+    start: int = 0,
+    end: Optional[int] = None,
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
+    env_override: str = "",
+) -> None:
+    with cfconfig_path.open("r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+    # For speedup
+    cfconfig.n_initial_agents = 1
+    cfconfig.apply_override(env_override)
+    phys_state = SavedPhysicsState.load(physstate_path)
+    env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
+    env_state, _ = env.reset(jax.random.PRNGKey(0))
+    end_index = end if end is not None else phys_state.circle_axy.shape[0]
+    visualizer = env.visualizer(
+        env_state,
+        figsize=(cfconfig.xlim[1] * 2, cfconfig.ylim[1] * 2),
+        backend=backend,
+    )
+    if videopath is not None:
+        visualizer = SaveVideoWrapper(visualizer, videopath, fps=60)
+    for i in range(start, end_index):
+        phys = phys_state.set_by_index(i, env_state.physics)
+        env_state = dataclasses.replace(env_state, physics=phys)
+        visualizer.render(env_state.physics)
+        visualizer.show()
+    visualizer.close()
+
+
+@app.command()
+def widget(
+    physstate_path: Path,
+    start: int = 0,
+    end: Optional[int] = None,
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
+    log_path: Optional[Path] = None,
+    self_terminate: bool = False,
+    profile_and_rewards_path: Optional[Path] = None,
+    cm_fixed_minmax: str = "",
+    env_override: str = "",
+) -> None:
+    from emevo.analysis.qt_widget import CFEnvReplayWidget, start_widget
+
+    with cfconfig_path.open("r") as f:
+        cfconfig = toml.from_toml(CfConfig, f.read())
+    # For speedup
+    cfconfig.n_initial_agents = 1
+    cfconfig.apply_override(env_override)
+    phys_state = SavedPhysicsState.load(physstate_path)
+    env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
+    end = phys_state.circle_axy.shape[0] if end is None else end
+    if log_path is None:
+        log_ds = None
+        step_offset = 0
+    else:
+        import pyarrow.dataset as ds
+
+        log_ds = ds.dataset(log_path)
+        step_offset = log_ds.scanner(columns=["step"]).head(1)["step"][0].as_py()
+
+    if profile_and_rewards_path is None:
+        profile_and_rewards = None
+    else:
+        import pyarrow.parquet as pq
+
+        profile_and_rewards = pq.read_table(profile_and_rewards_path)
+
+    if len(cm_fixed_minmax) > 0:
+        cm_fixed_minmax_dict = json.loads(cm_fixed_minmax)
+    else:
+        cm_fixed_minmax_dict = {}
+
+    start_widget(
+        CFEnvReplayWidget,
+        xlim=int(cfconfig.xlim[1]),
+        ylim=int(cfconfig.ylim[1]),
+        env=env,
+        saved_physics=phys_state,
+        start=start,
+        end=end,
+        log_ds=log_ds,
+        step_offset=step_offset,
+        self_terminate=self_terminate,
+        profile_and_rewards=profile_and_rewards,
+        cm_fixed_minmax=cm_fixed_minmax_dict,
+    )
+
+
+if __name__ == "__main__":
+    app()

From 2a84e96a8944c53145d75ef4295891e7a3d77c0f Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Wed, 13 Mar 2024 00:59:00 +0900
Subject: [PATCH 324/337] Log energy consumption

---
 src/emevo/environments/circle_foraging.py | 18 ++++++++++++------
 src/emevo/exp_utils.py                    |  3 ++-
 2 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 83bdab11..89b6794b 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -740,14 +740,16 @@ def step(
         sensor_obs = self._sensor_obs(stated=stated)
         # energy_delta = food - coef * |force|
         force_norm = jnp.sqrt(f1_raw**2 + f2_raw**2).ravel()
+        energy_consumption = (
+            self._force_energy_consumption * force_norm + self._basic_energy_consumption
+        )
         energy_delta = (
             jnp.sum(food_collision * self._food_energy_coef, axis=1)
-            - self._force_energy_consumption * force_norm
-            - self._basic_energy_consumption
+            - energy_consumption
         )
-        # Remove and reproduce foods
+        # Remove and regenerate foods
         key, food_key = jax.random.split(state.key)
-        stated, food_num, food_loc = self._remove_and_reproduce_foods(
+        stated, food_num, food_loc = self._remove_and_regenerate_foods(
             food_key,
             jnp.max(c2sc, axis=0),
             stated,
@@ -768,7 +770,11 @@ def step(
             angular_velocity=stated.circle.v.angle,
             energy=status.energy,
         )
-        timestep = TimeStep(encount=c2c, obs=obs)
+        timestep = TimeStep(
+            encount=c2c,
+            obs=obs,
+            info={"energy_consumption": energy_consumption},
+        )
         state = CFState(
             physics=stated,
             solver=solver,
@@ -976,7 +982,7 @@ def _initialize_physics_state(
 
         return stated, agentloc_state, foodloc_states
 
-    def _remove_and_reproduce_foods(
+    def _remove_and_regenerate_foods(
         self,
         key: chex.PRNGKey,
         eaten: jax.Array,
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 15832c49..81932e55 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -144,9 +144,10 @@ def load_model(self) -> gops.Mutation | gops.Crossover:
 class Log:
     dead: jax.Array
     got_food: jax.Array
+    consumed_energy: jax.Array
+    energy: jax.Array
     parents: jax.Array
     rewards: jax.Array
-    energy: jax.Array
     unique_id: jax.Array
 
     def with_step(self, from_: int) -> LogWithStep:

From f5427c44d9b9a3b7ef42e994e18c466f2978d16d Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Fri, 15 Mar 2024 14:23:34 +0900
Subject: [PATCH 325/337] Simplify simple

---
 experiments/cf_asexual_evo.py |   1 +
 experiments/cf_simple.py      | 275 +++-------------------------------
 src/emevo/genetic_ops.py      |  13 ++
 3 files changed, 32 insertions(+), 257 deletions(-)

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
index 8313e30f..de97c0e4 100644
--- a/experiments/cf_asexual_evo.py
+++ b/experiments/cf_asexual_evo.py
@@ -308,6 +308,7 @@ def step_rollout(
             rewards=rewards.ravel(),
             energy=state_t1db.status.energy,
             unique_id=state_t1db.unique_id.unique_id,
+            consumed_energy=timestep.info["energy_consumption"],
         )
         phys = state_t.physics  # type: ignore
         phys_state = SavedPhysicsState(
diff --git a/experiments/cf_simple.py b/experiments/cf_simple.py
index 47043c3c..5470da0d 100644
--- a/experiments/cf_simple.py
+++ b/experiments/cf_simple.py
@@ -1,6 +1,5 @@
 """Asexual reward evolution with Circle Foraging"""
 import dataclasses
-import enum
 import json
 from pathlib import Path
 from typing import Optional, cast
@@ -48,38 +47,18 @@
 PROJECT_ROOT = Path(__file__).parent.parent
 
 
-class RewardKind(str, enum.Enum):
-    BOUNDED_EXP = "bounded-exp"
-    DELAYED_SE = "delayed-se"
-    LINEAR = "linear"
-    EXPONENTIAL = "exponential"
-    OFFSET_DELAYED_SBE = "offset-delayed-sbe"
-    OFFSET_DELAYED_SE = "offset-delayed-se"
-    OFFSET_DELAYED_SINH = "offset-delayed-sinh"
-    SIGMOID = "sigmoid"
-    SIGMOID_01 = "sigmoid-01"
-    SIGMOID_EXP = "sigmoid-exp"
-    SINH = "sinh"
-
-
 @dataclasses.dataclass
 class RewardExtractor:
     act_space: BoxSpace
     act_coef: float
-    mask: dataclasses.InitVar[str] = "1111"
-    _mask_array: jax.Array = dataclasses.field(init=False)
     _max_norm: jax.Array = dataclasses.field(init=False)
 
-    def __post_init__(self, mask: str) -> None:
-        mask_array = jnp.array([x == "1" for x in mask])
-        self._mask_array = jnp.expand_dims(mask_array, axis=0)
-        self._max_norm = jnp.sqrt(
-            jnp.sum(self.act_space.high**2, axis=-1, keepdims=True)
-        )
+    def __post_init__(self) -> None:
+        self._max_norm = jnp.sqrt(jnp.sum(self.act_space.high**2, axis=-1))
 
     def normalize_action(self, action: jax.Array) -> jax.Array:
         scaled = self.act_space.sigmoid_scale(action)
-        norm = jnp.sqrt(jnp.sum(scaled**2, axis=-1, keepdims=True))
+        norm = jnp.sqrt(jnp.sum(scaled**2, axis=-1))
         return norm / self._max_norm
 
     def extract_linear(
@@ -90,7 +69,8 @@ def extract_linear(
     ) -> jax.Array:
         del energy
         act_input = self.act_coef * self.normalize_action(action)
-        return jnp.concatenate((collision, act_input), axis=1) * self._mask_array
+        food_collision = collision[:, 1]
+        return jnp.stack((food_collision, act_input))
 
     def extract_sigmoid(
         self,
@@ -98,158 +78,15 @@ def extract_sigmoid(
         action: jax.Array,
         energy: jax.Array,
     ) -> tuple[jax.Array, jax.Array]:
-        act_input = self.act_coef * self.normalize_action(action)
-        reward_input = jnp.concatenate((collision, act_input), axis=1)
-        return reward_input * self._mask_array, energy
+        return self.extract_linear(collision, action, energy), energy
 
 
 def linear_rs(w: jax.Array) -> dict[str, jax.Array]:
     return rfn.serialize_weight(w, ["food", "action"])
 
 
-def exp_rs(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(w, ["w_food", "w_action"])
-    scale_dict = rfn.serialize_weight(
-        scale,
-        ["scale_agent", "scale_food", "scale_wall", "scale_action"],
-    )
-    return w_dict | scale_dict
-
-
-def sigmoid_rs(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
-    alpha_dict = rfn.serialize_weight(
-        alpha,
-        ["alpha_agent", "alpha_food", "alpha_wall", "alpha_action"],
-    )
-    return w_dict | alpha_dict
-
-
-def delayed_sigmoid_rs(w: jax.Array, delay: jax.Array) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
-    delay_dict = rfn.serialize_weight(
-        delay,
-        ["delay_agent", "delay_food", "delay_wall", "delay_action"],
-    )
-    return w_dict | delay_dict
-
-
-def sigmoid_exp_rs(
-    w: jax.Array,
-    scale: jax.Array,
-    alpha: jax.Array,
-) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
-    alpha_dict = rfn.serialize_weight(
-        alpha,
-        ["alpha_agent", "alpha_food", "alpha_wall", "alpha_action"],
-    )
-    scale_dict = rfn.serialize_weight(
-        scale,
-        ["scale_agent", "scale_food", "scale_wall", "scale_action"],
-    )
-    return (w_dict | alpha_dict) | scale_dict
-
-
-def delayed_se_rs(
-    w: jax.Array,
-    scale: jax.Array,
-    delay: jax.Array,
-) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
-    delay_dict = rfn.serialize_weight(
-        delay,
-        ["delay_agent", "delay_food", "delay_wall", "delay_action"],
-    )
-    scale_dict = rfn.serialize_weight(
-        scale,
-        ["scale_agent", "scale_food", "scale_wall", "scale_action"],
-    )
-    return (w_dict | delay_dict) | scale_dict
-
-
 def linear_rs_withp(w: jax.Array) -> dict[str, jax.Array]:
-    return rfn.serialize_weight(w, ["agent", "food", "poison", "wall", "action"])
-
-
-def exp_rs_withp(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(
-        w,
-        ["w_agent", "w_food", "w_poison", "w_wall", "w_action"],
-    )
-    scale_dict = rfn.serialize_weight(
-        scale,
-        ["scale_agent", "scale_food", "scale_poison", "scale_wall", "scale_action"],
-    )
-    return w_dict | scale_dict
-
-
-def sigmoid_rs_withp(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(
-        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
-    )
-    alpha_dict = rfn.serialize_weight(
-        alpha,
-        ["alpha_agent", "alpha_food", "alpha_poison", "alpha_wall", "alpha_action"],
-    )
-    return w_dict | alpha_dict
-
-
-def delayed_sigmoid_rs_withp(w: jax.Array, delay: jax.Array) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(
-        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
-    )
-    threshold_dict = rfn.serialize_weight(
-        delay,
-        [
-            "threshold_agent",
-            "threshold_food",
-            "threshold_poison",
-            "threshold_wall",
-            "threshold_action",
-        ],
-    )
-    return w_dict | threshold_dict
-
-
-def sigmoid_exp_rs_withp(
-    w: jax.Array, scale: jax.Array, alpha: jax.Array
-) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(
-        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
-    )
-    alpha_dict = rfn.serialize_weight(
-        alpha,
-        ["alpha_agent", "alpha_food", "alpha_poison", "alpha_wall", "alpha_action"],
-    )
-    scale_dict = rfn.serialize_weight(
-        scale,
-        ["scale_agent", "scale_food", "scale_poison", "scale_wall", "scale_action"],
-    )
-    return (w_dict | alpha_dict) | scale_dict
-
-
-def delayed_se_rs_withp(
-    w: jax.Array, scale: jax.Array, delay: jax.Array
-) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(
-        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
-    )
-    threshold_dict = rfn.serialize_weight(
-        delay,
-        [
-            "threshold_agent",
-            "threshold_food",
-            "threshold_poison",
-            "threshold_wall",
-            "threshold_action",
-        ],
-    )
-    scale_dict = rfn.serialize_weight(
-        scale,
-        ["scale_agent", "scale_food", "scale_poison", "scale_wall", "scale_action"],
-    )
-    return (w_dict | threshold_dict) | scale_dict
+    return rfn.serialize_weight(w, ["food", "poison", "action"])
 
 
 def exec_rollout(
@@ -308,6 +145,7 @@ def step_rollout(
             rewards=rewards.ravel(),
             energy=state_t1db.status.energy,
             unique_id=state_t1db.unique_id.unique_id,
+            consumed_energy=timestep.info["energy_consumption"],
         )
         phys = state_t.physics  # type: ignore
         phys_state = SavedPhysicsState(
@@ -544,8 +382,6 @@ def evolve(
     env_override: str = "",
     birth_override: str = "",
     hazard_override: str = "",
-    reward_mask: Optional[str] = None,
-    reward_fn: RewardKind = RewardKind.LINEAR,
     logdir: Path = Path("./log"),
     log_mode: LogMode = LogMode.FULL,
     log_interval: int = 1000,
@@ -566,12 +402,6 @@ def evolve(
     bdconfig.apply_birth_override(birth_override)
     bdconfig.apply_hazard_override(hazard_override)
 
-    if reward_mask is None:
-        if poison_reward:
-            reward_mask = "11111"
-        else:
-            reward_mask = "1111"
-
     # Load models
     birth_fn, hazard_fn = bdconfig.load_models()
     mutation = gopsconfig.load_model()
@@ -586,86 +416,17 @@ def evolve(
     reward_extracor = RewardExtractor(
         act_space=env.act_space,  # type: ignore
         act_coef=act_reward_coef,
-        mask=reward_mask,
     )
-    common_rewardfn_args = {
-        "key": reward_key,
-        "n_agents": cfconfig.n_max_agents,
-        "n_weights": 5 if poison_reward else 4,
-        "std": gopsconfig.init_std,
-        "mean": gopsconfig.init_mean,
-    }
-    common_rewardfn_args |= gopsconfig.init_kwargs
-    if reward_fn == RewardKind.LINEAR:
-        reward_fn_instance = rfn.LinearReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_linear,
-            serializer=linear_rs_withp if poison_reward else linear_rs,
-        )
-    elif reward_fn == RewardKind.EXPONENTIAL:
-        reward_fn_instance = rfn.ExponentialReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_linear,
-            serializer=exp_rs_withp if poison_reward else exp_rs,
-        )
-    elif reward_fn == RewardKind.BOUNDED_EXP:
-        reward_fn_instance = rfn.BoundedExponentialReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_linear,
-            serializer=exp_rs_withp if poison_reward else exp_rs,
-        )
-    elif reward_fn == RewardKind.SIGMOID:
-        reward_fn_instance = rfn.SigmoidReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=sigmoid_rs_withp if poison_reward else sigmoid_rs,
-        )
-    elif reward_fn == RewardKind.SIGMOID_01:
-        reward_fn_instance = rfn.SigmoidReward_01(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=sigmoid_rs_withp if poison_reward else sigmoid_rs,
-        )
-    elif reward_fn == RewardKind.SIGMOID_EXP:
-        reward_fn_instance = rfn.SigmoidExponentialReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=sigmoid_exp_rs_withp if poison_reward else sigmoid_exp_rs,
-        )
-    elif reward_fn == RewardKind.DELAYED_SE:
-        reward_fn_instance = rfn.DelayedSEReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=delayed_se_rs_withp if poison_reward else delayed_se_rs,
-        )
-    elif reward_fn == RewardKind.OFFSET_DELAYED_SBE:
-        reward_fn_instance = rfn.OffsetDelayedSBEReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=delayed_se_rs_withp if poison_reward else delayed_se_rs,
-        )
-    elif reward_fn == RewardKind.OFFSET_DELAYED_SE:
-        reward_fn_instance = rfn.OffsetDelayedSEReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=delayed_se_rs_withp if poison_reward else delayed_se_rs,
-        )
-    elif reward_fn == RewardKind.SINH:
-        reward_fn_instance = rfn.SinhReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_linear,
-            serializer=linear_rs_withp if poison_reward else linear_rs,
-        )
-    elif reward_fn == RewardKind.OFFSET_DELAYED_SINH:
-        reward_fn_instance = rfn.OffsetDelayedSinhReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=delayed_sigmoid_rs_withp
-            if poison_reward
-            else delayed_sigmoid_rs,
-        )
-    else:
-        raise ValueError(f"Invalid reward_fn {reward_fn}")
+    reward_fn_instance = rfn.LinearReward(
+        key=reward_key,
+        n_agents=cfconfig.n_max_agents,
+        n_weights=5 if poison_reward else 4,
+        std=gopsconfig.init_std,
+        mean=gopsconfig.init_mean,
+        extractor=reward_extracor.extract_linear,
+        serializer=linear_rs_withp if poison_reward else linear_rs,
+        **gopsconfig.init_kwargs,
+    )
 
     logger = Logger(
         logdir=logdir,
diff --git a/src/emevo/genetic_ops.py b/src/emevo/genetic_ops.py
index 37343d6e..24f1ece6 100644
--- a/src/emevo/genetic_ops.py
+++ b/src/emevo/genetic_ops.py
@@ -143,3 +143,16 @@ def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
         )
         res = array + uniform
         return _clip_minmax(res, self.clip_min, self.clip_max)
+
+
+@dataclasses.dataclass(frozen=True)
+class CauchyMutation(Mutation):
+    loc: float = 0.0
+    scale: float = 1.0
+    clip_min: float | None = None
+    clip_max: float | None = None
+
+    def _add_noise(self, prng_key: chex.PRNGKey, array: jax.Array) -> jax.Array:
+        cauchy = jax.random.cauchy(prng_key, shape=array.shape)
+        res = array + self.loc + cauchy * self.scale
+        return _clip_minmax(res, self.clip_min, self.clip_max)

From 3aa40662895cfc86510a0a5cbfb1b35571a62d2a Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 16 Mar 2024 12:37:36 +0900
Subject: [PATCH 326/337] FoodLog

---
 experiments/cf_simple.py                  | 24 ++++++++------
 src/emevo/environments/circle_foraging.py | 22 ++++++++++---
 src/emevo/exp_utils.py                    | 38 +++++++++++++++++++++++
 3 files changed, 71 insertions(+), 13 deletions(-)

diff --git a/experiments/cf_simple.py b/experiments/cf_simple.py
index 5470da0d..fb36ec0c 100644
--- a/experiments/cf_simple.py
+++ b/experiments/cf_simple.py
@@ -25,6 +25,7 @@
 from emevo.exp_utils import (
     BDConfig,
     CfConfig,
+    FoodLog,
     GopsConfig,
     Log,
     Logger,
@@ -99,11 +100,11 @@ def exec_rollout(
     birth_fn: bd.BirthFunction,
     prng_key: jax.Array,
     n_rollout_steps: int,
-) -> tuple[State, Rollout, Log, SavedPhysicsState, Obs, jax.Array]:
+) -> tuple[State, Rollout, Log, FoodLog, SavedPhysicsState, Obs, jax.Array]:
     def step_rollout(
         carried: tuple[State, Obs],
         key: jax.Array,
-    ) -> tuple[tuple[State, Obs], tuple[Rollout, Log, SavedPhysicsState]]:
+    ) -> tuple[tuple[State, Obs], tuple[Rollout, Log, FoodLog, SavedPhysicsState]]:
         act_key, hazard_key, birth_key = jax.random.split(key, 3)
         state_t, obs_t = carried
         obs_t_array = obs_t.as_array()
@@ -147,6 +148,10 @@ def step_rollout(
             unique_id=state_t1db.unique_id.unique_id,
             consumed_energy=timestep.info["energy_consumption"],
         )
+        foodlog = FoodLog(
+            eaten=timestep.info["food_eaten"],
+            regenerated=timestep.info["food_regeneration"],
+        )
         phys = state_t.physics  # type: ignore
         phys_state = SavedPhysicsState(
             circle_axy=phys.circle.p.into_axy(),
@@ -155,15 +160,15 @@ def step_rollout(
             static_circle_is_active=phys.static_circle.is_active,
             static_circle_label=phys.static_circle.label,
         )
-        return (state_t1db, obs_t1), (rollout, log, phys_state)
+        return (state_t1db, obs_t1), (rollout, log, foodlog, phys_state)
 
-    (state, obs), (rollout, log, phys_state) = jax.lax.scan(
+    (state, obs), (rollout, log, foodlog, phys_state) = jax.lax.scan(
         step_rollout,
         (state, initial_obs),
         jax.random.split(prng_key, n_rollout_steps),
     )
     next_value = vmap_value(network, obs.as_array())
-    return state, rollout, log, phys_state, obs, next_value
+    return state, rollout, log, foodlog, phys_state, obs, next_value
 
 
 @eqx.filter_jit
@@ -183,9 +188,9 @@ def epoch(
     opt_state: optax.OptState,
     minibatch_size: int,
     n_optim_epochs: int,
-) -> tuple[State, Obs, Log, SavedPhysicsState, optax.OptState, NormalPPONet]:
+) -> tuple[State, Obs, Log, FoodLog, SavedPhysicsState, optax.OptState, NormalPPONet]:
     keys = jax.random.split(prng_key, env.n_max_agents + 1)
-    env_state, rollout, log, phys_state, obs, next_value = exec_rollout(
+    env_state, rollout, log, foodlog, phys_state, obs, next_value = exec_rollout(
         state,
         initial_obs,
         env,
@@ -208,7 +213,7 @@ def epoch(
         0.2,
         0.0,
     )
-    return env_state, obs, log, phys_state, opt_state, pponet
+    return env_state, obs, log, foodlog, phys_state, opt_state, pponet
 
 
 def run_evolution(
@@ -287,7 +292,7 @@ def replace_net(
 
     for i, key in enumerate(jax.random.split(key, n_total_steps // n_rollout_steps)):
         epoch_key, init_key = jax.random.split(key)
-        env_state, obs, log, phys_state, opt_state, pponet = epoch(
+        env_state, obs, log, foodlog, phys_state, opt_state, pponet = epoch(
             env_state,
             obs,
             env,
@@ -345,6 +350,7 @@ def replace_net(
 
         # Push log and physics state
         logger.push_log(log_with_step.filter_active())
+        logger.push_foodlog(foodlog)
         logger.push_physstate(phys_state)
 
     # Save logs before exiting
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 89b6794b..10647e25 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -749,7 +749,7 @@ def step(
         )
         # Remove and regenerate foods
         key, food_key = jax.random.split(state.key)
-        stated, food_num, food_loc = self._remove_and_regenerate_foods(
+        stated, food_num, food_loc, n_eaten, n_re = self._remove_and_regenerate_foods(
             food_key,
             jnp.max(c2sc, axis=0),
             stated,
@@ -773,7 +773,11 @@ def step(
         timestep = TimeStep(
             encount=c2c,
             obs=obs,
-            info={"energy_consumption": energy_consumption},
+            info={
+                "energy_consumption": energy_consumption,
+                "food_regeneration": n_re.astype(bool),
+                "food_eaten": n_eaten,
+            },
         )
         state = CFState(
             physics=stated,
@@ -990,7 +994,9 @@ def _remove_and_regenerate_foods(
         n_steps: jax.Array,
         food_num_states: list[FoodNumState],
         food_loc_states: list[LocatingState],
-    ) -> tuple[StateDict, list[FoodNumState], list[LocatingState]]:
+    ) -> tuple[
+        StateDict, list[FoodNumState], list[LocatingState], jax.Array, jax.Array
+    ]:
         # Remove foods
         xy = jnp.where(
             jnp.expand_dims(eaten, axis=1),
@@ -1005,6 +1011,7 @@ def _remove_and_regenerate_foods(
         )
         sc = sd.static_circle
         # Regenerate food for each source
+        n_generated_foods = jnp.zeros(self._n_food_sources, dtype=jnp.int32)
         for i in range(self._n_food_sources):
             food_num = self._food_num_fns[i](
                 n_steps,
@@ -1034,7 +1041,14 @@ def _remove_and_regenerate_foods(
             incr = jnp.sum(place)
             food_num_states[i] = food_num.recover(incr)
             food_loc_states[i] = food_loc.increment(incr)
-        return replace(sd, static_circle=sc), food_num_states, food_loc_states
+            n_generated_foods = n_generated_foods.at[i].add(incr)
+        return (
+            replace(sd, static_circle=sc),
+            food_num_states,
+            food_loc_states,
+            eaten_per_source,
+            n_generated_foods,
+        )
 
     def visualizer(
         self,
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index 81932e55..d31035e9 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -172,6 +172,12 @@ def with_step(self, from_: int) -> LogWithStep:
             )
 
 
+@chex.dataclass
+class FoodLog:
+    eaten: jax.Array  # i32, [N_FOOD_SOURCES,]
+    regenerated: jax.Array  # bool, [N_FOOD_SOURCES,]
+
+
 @chex.dataclass
 class LogWithStep(Log):
     step: jax.Array
@@ -284,6 +290,7 @@ class Logger:
     reward_fn_dict: dict[int, RewardFn] = dataclasses.field(default_factory=dict)
     profile_dict: dict[int, SavedProfile] = dataclasses.field(default_factory=dict)
     _log_list: list[Log] = dataclasses.field(default_factory=list, init=False)
+    _foodlog_list: list[FoodLog] = dataclasses.field(default_factory=list, init=False)
     _physstate_list: list[SavedPhysicsState] = dataclasses.field(
         default_factory=list,
         init=False,
@@ -321,6 +328,37 @@ def _save_log(self) -> None:
         self._log_index += 1
         self._log_list.clear()
 
+    def push_foodlog(self, log: FoodLog) -> None:
+        if self.mode not in [LogMode.FULL, LogMode.REWARD_AND_LOG]:
+            return
+
+        # Move log to CPU
+        self._foodlog_list.append(jax.tree_map(np.array, log))
+
+        if len(self._log_list) % self.log_interval == 0:
+            self._save_foodlog()
+
+    def _save_foodlog(self) -> None:
+        if len(self._log_list) == 0:
+            return
+
+        all_log = jax.tree_map(
+            lambda *args: np.stack(args, axis=0),
+            *self._log_list,
+        )
+        log_dict = {}
+        for i in range(all_log.eaten.shape[1]):
+            log_dict[f"eaten_{i}"] = all_log.eaten[:, i]
+            log_dict[f"regen_{i}"] = all_log.regenerated[:, i]
+
+        # Don't change log_index here
+        pq.write_table(
+            pa.Table.from_pydict(log_dict),
+            self.logdir.joinpath(f"foodlog-{self._log_index}.parquet"),
+            compression="zstd",
+        )
+        self._foodlog_list.clear()
+
     def push_physstate(self, phys_state: SavedPhysicsState) -> None:
         if self.mode != LogMode.FULL:
             return

From 75540367ba86af589632f0b375b735ec17d45656 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sat, 16 Mar 2024 12:49:46 +0900
Subject: [PATCH 327/337] Fix pyserde version

---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index cccf0e98..9a473d65 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -26,7 +26,7 @@ dependencies = [
     "moderngl-window >= 2.4",
     "jax >= 0.4",
     "pyarrow >= 8.0",
-    "pyserde[toml] >= 0.12",
+    "pyserde[toml] == 0.13.2",  # TODO: update
     "optax >= 0.1",
 ]
 dynamic = ["version"]

From 92940fedfbbbd27b6a24cbda89b7ea6a3b6111ab Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Sun, 17 Mar 2024 20:30:37 +0900
Subject: [PATCH 328/337] Make cf_simple work

---
 experiments/cf_simple.py | 20 +++++++++-----------
 src/emevo/exp_utils.py   |  9 +++++----
 2 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/experiments/cf_simple.py b/experiments/cf_simple.py
index fb36ec0c..a2f87ec0 100644
--- a/experiments/cf_simple.py
+++ b/experiments/cf_simple.py
@@ -71,7 +71,7 @@ def extract_linear(
         del energy
         act_input = self.act_coef * self.normalize_action(action)
         food_collision = collision[:, 1]
-        return jnp.stack((food_collision, act_input))
+        return jnp.stack((food_collision, act_input), axis=1)
 
     def extract_sigmoid(
         self,
@@ -82,12 +82,11 @@ def extract_sigmoid(
         return self.extract_linear(collision, action, energy), energy
 
 
-def linear_rs(w: jax.Array) -> dict[str, jax.Array]:
-    return rfn.serialize_weight(w, ["food", "action"])
-
-
-def linear_rs_withp(w: jax.Array) -> dict[str, jax.Array]:
-    return rfn.serialize_weight(w, ["food", "poison", "action"])
+def serialize_weight(w: jax.Array) -> dict[str, jax.Array]:
+    wd = w.shape[0]
+    rd = {f"food_{i + 1}": rfn.slice_last(w, i) for i in range(wd - 1)}
+    rd["action"] = rfn.slice_last(w, wd - 1)
+    return rd
 
 
 def exec_rollout(
@@ -389,10 +388,9 @@ def evolve(
     birth_override: str = "",
     hazard_override: str = "",
     logdir: Path = Path("./log"),
-    log_mode: LogMode = LogMode.FULL,
+    log_mode: LogMode = LogMode.REWARD_AND_LOG,
     log_interval: int = 1000,
     savestate_interval: int = 1000,
-    poison_reward: bool = False,
     debug_vis: bool = False,
 ) -> None:
     # Load config
@@ -426,11 +424,11 @@ def evolve(
     reward_fn_instance = rfn.LinearReward(
         key=reward_key,
         n_agents=cfconfig.n_max_agents,
-        n_weights=5 if poison_reward else 4,
+        n_weights=1 + cfconfig.n_food_sources,
         std=gopsconfig.init_std,
         mean=gopsconfig.init_mean,
         extractor=reward_extracor.extract_linear,
-        serializer=linear_rs_withp if poison_reward else linear_rs,
+        serializer=serialize_weight,
         **gopsconfig.init_kwargs,
     )
 
diff --git a/src/emevo/exp_utils.py b/src/emevo/exp_utils.py
index d31035e9..ecc87251 100644
--- a/src/emevo/exp_utils.py
+++ b/src/emevo/exp_utils.py
@@ -339,17 +339,17 @@ def push_foodlog(self, log: FoodLog) -> None:
             self._save_foodlog()
 
     def _save_foodlog(self) -> None:
-        if len(self._log_list) == 0:
+        if len(self._foodlog_list) == 0:
             return
 
         all_log = jax.tree_map(
             lambda *args: np.stack(args, axis=0),
-            *self._log_list,
+            *self._foodlog_list,
         )
         log_dict = {}
         for i in range(all_log.eaten.shape[1]):
-            log_dict[f"eaten_{i}"] = all_log.eaten[:, i]
-            log_dict[f"regen_{i}"] = all_log.regenerated[:, i]
+            log_dict[f"eaten_{i}"] = all_log.eaten[:, i].ravel()
+            log_dict[f"regen_{i}"] = all_log.regenerated[:, i].ravel()
 
         # Don't change log_index here
         pq.write_table(
@@ -408,6 +408,7 @@ def finalize(self) -> None:
 
         if self.mode in [LogMode.FULL, LogMode.REWARD_AND_LOG]:
             self._save_log()
+            self._save_foodlog()
 
         if self.mode == LogMode.FULL:
             self._save_physstate()

From b43fb3470483e7220a4a128e035726983c066226 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 18 Mar 2024 17:42:28 +0900
Subject: [PATCH 329/337] Slope models

---
 config/bd/20240318-mild-slope.toml | 13 ++++++++++
 config/gops/20240318-cauchy.toml   |  6 +++++
 experiments/cf_simple.py           | 19 ++++++++-------
 src/emevo/birth_and_death.py       | 39 ++++++++++++++++++++++++++++++
 4 files changed, 68 insertions(+), 9 deletions(-)
 create mode 100644 config/bd/20240318-mild-slope.toml
 create mode 100644 config/gops/20240318-cauchy.toml

diff --git a/config/bd/20240318-mild-slope.toml b/config/bd/20240318-mild-slope.toml
new file mode 100644
index 00000000..cabac09c
--- /dev/null
+++ b/config/bd/20240318-mild-slope.toml
@@ -0,0 +1,13 @@
+birth_fn = "emevo.birth_and_death.SlopeELBirth"
+hazard_fn = "emevo.birth_and_death.SlopeELGHazard"
+
+[hazard_params]
+scale = 0.01
+alpha = 0.1
+slope = 1.0 # 0.2
+alpha_age = 1e-6
+beta = 1e-5
+
+[birth_params]
+scale = 4e-4
+slope = 0.1
\ No newline at end of file
diff --git a/config/gops/20240318-cauchy.toml b/config/gops/20240318-cauchy.toml
new file mode 100644
index 00000000..032de50e
--- /dev/null
+++ b/config/gops/20240318-cauchy.toml
@@ -0,0 +1,6 @@
+path = "emevo.genetic_ops.CauchyMutation"
+init_std = 0.1
+init_mean = 0.0
+
+[params]
+loc = 0.0
\ No newline at end of file
diff --git a/experiments/cf_simple.py b/experiments/cf_simple.py
index a2f87ec0..612818b2 100644
--- a/experiments/cf_simple.py
+++ b/experiments/cf_simple.py
@@ -187,6 +187,7 @@ def epoch(
     opt_state: optax.OptState,
     minibatch_size: int,
     n_optim_epochs: int,
+    entropy_weight: float,
 ) -> tuple[State, Obs, Log, FoodLog, SavedPhysicsState, optax.OptState, NormalPPONet]:
     keys = jax.random.split(prng_key, env.n_max_agents + 1)
     env_state, rollout, log, foodlog, phys_state, obs, next_value = exec_rollout(
@@ -210,7 +211,7 @@ def epoch(
         minibatch_size,
         n_optim_epochs,
         0.2,
-        0.0,
+        entropy_weight,
     )
     return env_state, obs, log, foodlog, phys_state, opt_state, pponet
 
@@ -227,6 +228,7 @@ def run_evolution(
     minibatch_size: int,
     n_rollout_steps: int,
     n_total_steps: int,
+    entropy_weight: float,
     reward_fn: rfn.RewardFn,
     hazard_fn: bd.HazardFunction,
     birth_fn: bd.BirthFunction,
@@ -307,6 +309,7 @@ def replace_net(
             opt_state,
             minibatch_size,
             n_optim_epochs,
+            entropy_weight,
         )
 
         if visualizer is not None:
@@ -368,8 +371,6 @@ def replace_net(
 @app.command()
 def evolve(
     seed: int = 1,
-    n_agents: int = 20,
-    init_energy: float = 20.0,
     action_cost: float = 0.0001,
     mutation_prob: float = 0.2,
     adam_lr: float = 3e-4,
@@ -381,9 +382,10 @@ def evolve(
     n_rollout_steps: int = 1024,
     n_total_steps: int = 1024 * 10000,
     act_reward_coef: float = 0.001,
-    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
-    bdconfig_path: Path = PROJECT_ROOT / "config/bd/20230530-a035-e020.toml",
-    gopsconfig_path: Path = PROJECT_ROOT / "config/gops/20240111-mutation-0401.toml",
+    entropy_weight: float = 0.001,
+    cfconfig_path: Path = PROJECT_ROOT / "config/env/20240224-ls-square.toml",
+    bdconfig_path: Path = PROJECT_ROOT / "config/bd/20240318-mild-slope.toml",
+    gopsconfig_path: Path = PROJECT_ROOT / "config/gops/20240318-cauchy.toml",
     env_override: str = "",
     birth_override: str = "",
     hazard_override: str = "",
@@ -410,8 +412,6 @@ def evolve(
     birth_fn, hazard_fn = bdconfig.load_models()
     mutation = gopsconfig.load_model()
     # Override config
-    cfconfig.n_initial_agents = n_agents
-    cfconfig.init_energy = init_energy
     cfconfig.force_energy_consumption = action_cost
     gopsconfig.params["mutation_prob"] = mutation_prob
     # Make env
@@ -441,7 +441,7 @@ def evolve(
     run_evolution(
         key=key,
         env=env,
-        n_initial_agents=n_agents,
+        n_initial_agents=cfconfig.n_initial_agents,
         adam=optax.adam(adam_lr, eps=adam_eps),
         gamma=gamma,
         gae_lambda=gae_lambda,
@@ -449,6 +449,7 @@ def evolve(
         minibatch_size=minibatch_size,
         n_rollout_steps=n_rollout_steps,
         n_total_steps=n_total_steps,
+        entropy_weight=entropy_weight,
         reward_fn=reward_fn_instance,
         hazard_fn=hazard_fn,
         birth_fn=birth_fn,
diff --git a/src/emevo/birth_and_death.py b/src/emevo/birth_and_death.py
index fc898bcb..d11ebbb1 100644
--- a/src/emevo/birth_and_death.py
+++ b/src/emevo/birth_and_death.py
@@ -149,6 +149,31 @@ def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         return ht - h0
 
 
+@dataclasses.dataclass(frozen=True)
+class SlopeELGHazard(EnergyLogisticHazard):
+    alpha: float = 0.1
+    scale: float = 1.0
+    slope: float = 0.1
+    alpha_age: float = 1e-6
+    beta: float = 1e-5
+
+    def _energy_death_rate(self, energy: jax.Array) -> jax.Array:
+        return self.scale * (
+            1.0 - 1.0 / (1.0 + self.alpha * jnp.exp(-energy * self.slope))
+        )
+
+    def __call__(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        age = self.alpha_age * jnp.exp(self.beta * age)
+        energy = self._energy_death_rate(energy)
+        return age + energy
+
+    def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        energy = self._energy_death_rate(energy) * age
+        ht = energy + self.alpha_age / self.beta * jnp.exp(self.beta * age)
+        h0 = self.alpha_age / self.beta
+        return ht - h0
+
+
 class BirthFunction(Protocol):
     def __call__(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         """Birth function b(t)"""
@@ -179,6 +204,20 @@ def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
         return age * self(age, energy)
 
 
+@dataclasses.dataclass(frozen=True)
+class SlopeELBirth(BirthFunction):
+    slope: float = 1.0
+    scale: float = 0.1
+
+    def __call__(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        del age
+        return self.scale / (1.0 + jnp.exp(-energy * self.slope))
+
+    def cumulative(self, age: jax.Array, energy: jax.Array) -> jax.Array:
+        """Birth function b(t)"""
+        return age * self(age, energy)
+
+
 def compute_cumulative_hazard(
     hazard: HazardFunction,
     *,

From fd3f637ed3656d406a910e068ed2dadb0fdf17a0 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 18 Mar 2024 17:43:14 +0900
Subject: [PATCH 330/337] get_relative_angle

---
 src/emevo/environments/phyjax2d.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 696e6470..4918a4ec 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -250,6 +250,13 @@ def batch_size(self) -> int:
         return self.p.batch_size()
 
 
+def get_relative_angle(s_a: State, s_b: State) -> jax.Array:
+    a2b_x, a2b_y = _get_xy(s_b.p.xy - s_a.p.xy)
+    a2b_angle = jnp.arctan2(a2b_y, a2b_x)
+    return (a2b_angle - s_a.p.angle + 2.0 * TWO_PI) % TWO_PI
+
+
+
 @chex.dataclass
 class Contact(PyTreeOps):
     pos: jax.Array

From b4c0dcc5a9ba00a82e2f226783baff1c07e91a3a Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 19 Mar 2024 12:03:17 +0900
Subject: [PATCH 331/337] Adjust slope params

---
 config/bd/20240318-mild-slope.toml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/config/bd/20240318-mild-slope.toml b/config/bd/20240318-mild-slope.toml
index cabac09c..0d731fde 100644
--- a/config/bd/20240318-mild-slope.toml
+++ b/config/bd/20240318-mild-slope.toml
@@ -3,11 +3,11 @@ hazard_fn = "emevo.birth_and_death.SlopeELGHazard"
 
 [hazard_params]
 scale = 0.01
-alpha = 0.1
-slope = 1.0 # 0.2
-alpha_age = 1e-6
-beta = 1e-5
+alpha = 0.02
+slope = 0.2
+alpha_age = 1e-7
+beta = 4e-6
 
 [birth_params]
 scale = 4e-4
-slope = 0.1
\ No newline at end of file
+slope = 0.1

From a5e60cbb653004997adbce376a4f4d31940a7440 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Tue, 19 Mar 2024 19:21:40 +0900
Subject: [PATCH 332/337] [Experimental] tactile sensing and limited mouth
 range

---
 experiments/cf_simple.py                  |   7 +-
 src/emevo/environments/circle_foraging.py | 137 ++++++++++++++++------
 src/emevo/environments/phyjax2d.py        |   4 +-
 3 files changed, 109 insertions(+), 39 deletions(-)

diff --git a/experiments/cf_simple.py b/experiments/cf_simple.py
index 612818b2..ea4fd584 100644
--- a/experiments/cf_simple.py
+++ b/experiments/cf_simple.py
@@ -148,8 +148,8 @@ def step_rollout(
             consumed_energy=timestep.info["energy_consumption"],
         )
         foodlog = FoodLog(
-            eaten=timestep.info["food_eaten"],
-            regenerated=timestep.info["food_regeneration"],
+            eaten=timestep.info["n_food_eaten"],
+            regenerated=timestep.info["n_food_regenerated"],
         )
         phys = state_t.physics  # type: ignore
         phys_state = SavedPhysicsState(
@@ -315,6 +315,9 @@ def replace_net(
         if visualizer is not None:
             visualizer.render(env_state.physics)  # type: ignore
             visualizer.show()
+            popl = jnp.sum(env_state.unique_id.is_active())
+            print(f"Population: {int(popl)}")
+
         # Extinct?
         n_active = jnp.sum(env_state.unique_id.is_active())  # type: ignore
         if n_active == 0:
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 10647e25..751ac0b6 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -43,6 +43,7 @@
     Velocity,
     VelocitySolver,
     circle_raycast,
+    get_relative_angle,
     segment_raycast,
 )
 from emevo.environments.phyjax2d import step as physics_step
@@ -77,7 +78,7 @@ def as_array(self) -> jax.Array:
         return jnp.concatenate(
             (
                 self.sensor.reshape(self.sensor.shape[0], -1),
-                self.collision,
+                self.collision.reshape(self.collision.shape[0], -1),
                 self.velocity,
                 jnp.expand_dims(self.angle, axis=1),
                 jnp.expand_dims(self.angular_velocity, axis=1),
@@ -317,6 +318,49 @@ def get_sensor_obs(
         return _vmap_obs_closest_with_food(n_food_labels, shaped, p1, p2, stated)
 
 
+@functools.partial(jax.vmap, in_axes=(0, None))
+def _search_bin(value: jax.Array, bins: jax.Array) -> jax.Array:
+    smaller = value <= bins[1:]
+    larger = bins[:-1] <= value
+    return jnp.logical_and(smaller, larger)
+
+
+def _get_tactile(
+    n_bins: int,
+    s1: State,
+    s2: State,
+    collision_mat: jax.Array,
+) -> tuple[jax.Array, jax.Array]:
+    nm_shape = collision_mat.shape
+    rel_angle = get_relative_angle(s1, s2)  # [0, 2π]
+    weights = (jnp.pi * 2 / n_bins) * jnp.arange(n_bins + 1)  # [0, ..., 2π]
+    in_range = _search_bin(rel_angle.ravel(), weights).reshape(*nm_shape, n_bins)
+    tactile_raw = in_range * jnp.expand_dims(collision_mat, axis=2)
+    tactile = jnp.sum(tactile_raw, axis=1, keepdims=True)  # (N, 1, B)
+    return tactile, tactile_raw
+
+
+def _food_tactile_with_labels(
+    n_bins: int,
+    n_food_sources: int,
+    food_labels: jax.Array,
+    s1: State,
+    s2: State,
+    collision_mat: jax.Array,
+) -> tuple[jax.Array, jax.Array]:
+    nm_shape = collision_mat.shape
+    rel_angle = get_relative_angle(s1, s2)  # [0, 2π]
+    weights = (jnp.pi * 2 / n_bins) * jnp.arange(n_bins + 1)  # [0, ..., 2π]
+    in_range = _search_bin(rel_angle.ravel(), weights).reshape(*nm_shape, n_bins)
+    in_range_masked = in_range * jnp.expand_dims(collision_mat, axis=2)
+    onehot = jax.nn.one_hot(food_labels, n_food_sources, dtype=bool)
+    expanded_onehot = onehot.reshape(1, *onehot.shape, 1)  # (1, M, L, 1)
+    expanded_in_range = jnp.expand_dims(in_range_masked, axis=2)  # (N, M, 1, B)
+    tactile_raw = expanded_in_range * expanded_onehot  # (N, M, L, B)
+    tactile = jnp.sum(tactile_raw, axis=1)  # (N, L, B)
+    return tactile, tactile_raw
+
+
 @functools.partial(jax.jit, static_argnums=(0, 1))
 def nstep(
     n: int,
@@ -367,8 +411,10 @@ def __init__(
         env_shape: Literal["square", "circle"] = "square",
         obstacles: list[tuple[Vec2d, Vec2d]] | str = "none",
         newborn_loc: Literal["neighbor", "uniform"] = "neighbor",
+        mouth_pos: Literal["all", "front"] = "front",
         neighbor_stddev: float = 40.0,
         n_agent_sensors: int = 16,
+        n_tactile_bins: int = 6,
         sensor_length: float = 100.0,
         sensor_range: tuple[float, float] | SensorRange = SensorRange.WIDE,
         agent_radius: float = 10.0,
@@ -436,6 +482,13 @@ def __init__(
         self._agent_loc_fn, self._initial_agentloc_state = self._make_agent_loc_fn(
             agent_loc_fn
         )
+        # Foraging
+        if mouth_pos == "all":
+            self._foraging_indices = tuple(range(n_tactile_bins))
+        elif mouth_pos == "front":
+            self._foraging_indices = 0, n_tactile_bins - 1
+        else:
+            raise ValueError(f"Unsupported mouth_pos {mouth_pos}")
         # Energy
         self._force_energy_consumption = force_energy_consumption
         self._basic_energy_consumption = basic_energy_consumption
@@ -474,6 +527,7 @@ def __init__(
         self._n_physics_iter = n_physics_iter
         # Obs
         self._n_sensors = n_agent_sensors
+        self._n_tactile_bins = n_tactile_bins
         # Some cached constants
         act_p1 = Vec2d(0, agent_radius).rotated(np.pi * 0.75)
         act_p2 = Vec2d(0, agent_radius).rotated(-np.pi * 0.75)
@@ -581,16 +635,14 @@ def place_newborn_neighbor(
                 )
             )
 
-            def food_collision_with_labels(
-                c2sc: jax.Array,
-                label: jax.Array,
-            ) -> jax.Array:
-                onehot = jax.nn.one_hot(label, self._n_food_sources, dtype=bool)
-                expanded_c2sc = jnp.expand_dims(c2sc, axis=2)  # (AGENT, FOOD, 1)
-                expanded_onehot = jnp.expand_dims(onehot, axis=0)  # (1, FOOD, LABEL)
-                return jnp.max(expanded_c2sc * expanded_onehot, axis=1)
-
-            self._food_collision = food_collision_with_labels
+            self._food_tactile = lambda labels, s1, s2, cmat: _food_tactile_with_labels(
+                self._n_tactile_bins,
+                self._n_food_sources,
+                labels,
+                s1,
+                s2,
+                cmat,
+            )
             self._n_obj = N_OBJECTS + self._n_food_sources - 1
 
         else:
@@ -605,7 +657,12 @@ def food_collision_with_labels(
                 )
             )
 
-            self._food_collision = lambda c2sc, _: jnp.max(c2sc, axis=1, keepdims=True)
+            self._food_tactile = lambda _, s1, s2, cmat: _get_tactile(
+                self._n_tactile_bins,
+                s1,
+                s2,
+                cmat,
+            )
             self._n_obj = N_OBJECTS
 
         # Spaces
@@ -727,13 +784,27 @@ def step(
         c2c = self._physics.get_contact_mat("circle", "circle", contacts)
         c2sc = self._physics.get_contact_mat("circle", "static_circle", contacts)
         seg2c = self._physics.get_contact_mat("segment", "circle", contacts)
-        food_collision = self._food_collision(c2sc, stated.static_circle.label)
+        # Get tactile obs
+        food_tactile, ft_raw = self._food_tactile(
+            stated.static_circle.label,
+            stated.circle,
+            stated.static_circle,
+            c2sc,
+        )
+        ag_tactile, _ = _get_tactile(
+            self._n_tactile_bins,
+            stated.circle,
+            stated.circle,
+            c2c,
+        )
+        wall_tactile, _ = _get_tactile(
+            self._n_tactile_bins,
+            stated.circle,
+            stated.segment,
+            seg2c.transpose(),
+        )
         collision = jnp.concatenate(
-            (
-                jnp.max(c2c, axis=1, keepdims=True),  # (N, 1)
-                food_collision,  # (N, N_LABELS)
-                jnp.max(seg2c, axis=0, keepdims=True).T,
-            ),
+            (food_tactile > 0, ag_tactile > 0, wall_tactile > 0),
             axis=1,
         )
         # Gather sensor obs
@@ -743,15 +814,16 @@ def step(
         energy_consumption = (
             self._force_energy_consumption * force_norm + self._basic_energy_consumption
         )
+        n_ate = jnp.sum(food_tactile[:, :, self._foraging_indices], axis=-1)
         energy_delta = (
-            jnp.sum(food_collision * self._food_energy_coef, axis=1)
-            - energy_consumption
+            jnp.sum(n_ate * self._food_energy_coef, axis=1) - energy_consumption
         )
         # Remove and regenerate foods
         key, food_key = jax.random.split(state.key)
-        stated, food_num, food_loc, n_eaten, n_re = self._remove_and_regenerate_foods(
+        eaten = jnp.sum(ft_raw[:, :, :, self._foraging_indices], axis=(0, 3)) > 0
+        stated, food_num, food_loc, n_regen = self._remove_and_regenerate_foods(
             food_key,
-            jnp.max(c2sc, axis=0),
+            eaten,  # (N_FOOD, N_LABEL)
             stated,
             state.step,
             state.food_num,
@@ -775,8 +847,9 @@ def step(
             obs=obs,
             info={
                 "energy_consumption": energy_consumption,
-                "food_regeneration": n_re.astype(bool),
-                "food_eaten": n_eaten,
+                "n_food_regenerated": n_regen.astype(bool),
+                "n_food_eaten": jnp.sum(eaten, axis=0),  # (N_LABEL,)
+                "n_ate_food": n_ate,  # (N_AGENT, N_LABEL)
             },
         )
         state = CFState(
@@ -989,14 +1062,13 @@ def _initialize_physics_state(
     def _remove_and_regenerate_foods(
         self,
         key: chex.PRNGKey,
-        eaten: jax.Array,
+        eaten_per_source: jax.Array,
         sd: StateDict,
         n_steps: jax.Array,
         food_num_states: list[FoodNumState],
         food_loc_states: list[LocatingState],
-    ) -> tuple[
-        StateDict, list[FoodNumState], list[LocatingState], jax.Array, jax.Array
-    ]:
+    ) -> tuple[StateDict, list[FoodNumState], list[LocatingState], jax.Array]:
+        eaten = jnp.sum(eaten_per_source, axis=1) > 0
         # Remove foods
         xy = jnp.where(
             jnp.expand_dims(eaten, axis=1),
@@ -1004,18 +1076,14 @@ def _remove_and_regenerate_foods(
             sd.static_circle.p.xy,
         )
         is_active = jnp.logical_and(sd.static_circle.is_active, jnp.logical_not(eaten))
-        eaten_per_source = (
-            jnp.zeros(self._n_food_sources, dtype=jnp.int32)
-            .at[sd.static_circle.label]
-            .add(eaten)
-        )
+        n_eaten_per_source = jnp.sum(eaten_per_source, axis=0)
         sc = sd.static_circle
         # Regenerate food for each source
         n_generated_foods = jnp.zeros(self._n_food_sources, dtype=jnp.int32)
         for i in range(self._n_food_sources):
             food_num = self._food_num_fns[i](
                 n_steps,
-                food_num_states[i].eaten(eaten_per_source[i]),
+                food_num_states[i].eaten(n_eaten_per_source[i]),
             )
             food_loc = food_loc_states[i]
             first_inactive = nth_true(jnp.logical_not(is_active), i + 1)
@@ -1046,7 +1114,6 @@ def _remove_and_regenerate_foods(
             replace(sd, static_circle=sc),
             food_num_states,
             food_loc_states,
-            eaten_per_source,
             n_generated_foods,
         )
 
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 4918a4ec..50e28720 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -99,7 +99,8 @@ class _PositionLike(Protocol):
     angle: jax.Array  # Angular velocity (N,)
     xy: jax.Array  # (N, 2)
 
-    def __init__(self, angle: jax.Array, xy: jax.Array) -> None: ...
+    def __init__(self, angle: jax.Array, xy: jax.Array) -> None:
+        ...
 
     def batch_size(self) -> int:
         return self.angle.shape[0]
@@ -256,7 +257,6 @@ def get_relative_angle(s_a: State, s_b: State) -> jax.Array:
     return (a2b_angle - s_a.p.angle + 2.0 * TWO_PI) % TWO_PI
 
 
-
 @chex.dataclass
 class Contact(PyTreeOps):
     pos: jax.Array

From 02a7d438515f01f397e4eda4ac039368b59827bc Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 21 Mar 2024 01:04:02 +0900
Subject: [PATCH 333/337] Fix get_relative_angle ad modify test_observe

---
 src/emevo/environments/circle_foraging.py |  8 ++++----
 src/emevo/environments/phyjax2d.py        |  9 ++++++---
 tests/test_observe.py                     | 14 +++++++-------
 3 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 751ac0b6..40e5f77a 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -332,12 +332,12 @@ def _get_tactile(
     collision_mat: jax.Array,
 ) -> tuple[jax.Array, jax.Array]:
     nm_shape = collision_mat.shape
-    rel_angle = get_relative_angle(s1, s2)  # [0, 2π]
+    rel_angle = get_relative_angle(s1, s2)  # [0, 2π]  (N, M)
     weights = (jnp.pi * 2 / n_bins) * jnp.arange(n_bins + 1)  # [0, ..., 2π]
     in_range = _search_bin(rel_angle.ravel(), weights).reshape(*nm_shape, n_bins)
-    tactile_raw = in_range * jnp.expand_dims(collision_mat, axis=2)
+    tactile_raw = in_range * jnp.expand_dims(collision_mat, axis=2)  # (N, M, B)
     tactile = jnp.sum(tactile_raw, axis=1, keepdims=True)  # (N, 1, B)
-    return tactile, tactile_raw
+    return tactile, jnp.expand_dims(tactile_raw, axis=2)  # (N, M, 1, B)
 
 
 def _food_tactile_with_labels(
@@ -804,7 +804,7 @@ def step(
             seg2c.transpose(),
         )
         collision = jnp.concatenate(
-            (food_tactile > 0, ag_tactile > 0, wall_tactile > 0),
+            (ag_tactile > 0, food_tactile > 0, wall_tactile > 0),
             axis=1,
         )
         # Gather sensor obs
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 50e28720..547fb6b0 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -252,9 +252,12 @@ def batch_size(self) -> int:
 
 
 def get_relative_angle(s_a: State, s_b: State) -> jax.Array:
-    a2b_x, a2b_y = _get_xy(s_b.p.xy - s_a.p.xy)
-    a2b_angle = jnp.arctan2(a2b_y, a2b_x)
-    return (a2b_angle - s_a.p.angle + 2.0 * TWO_PI) % TWO_PI
+    a2b = jax.vmap(jnp.subtract, in_axes=(None, 0))(s_b.p.xy, s_a.p.xy)
+    a2b_x, a2b_y = _get_xy(a2b)
+    a2b_angle = jnp.arctan2(a2b_y, a2b_x)  # (N_A, N_B)
+    a_angle = jnp.expand_dims(s_a.p.angle, axis=1)
+    # Subtract 0.5𝛑 because our angle starts from 0.5𝛑 (90 degree)
+    return (a2b_angle - a_angle + TWO_PI * 3 - jnp.pi * 0.5) % TWO_PI
 
 
 @chex.dataclass
diff --git a/tests/test_observe.py b/tests/test_observe.py
index 13f3f3ec..f0c54df0 100644
--- a/tests/test_observe.py
+++ b/tests/test_observe.py
@@ -238,13 +238,13 @@ def test_encount_and_collision(key: chex.PRNGKey) -> None:
         if not p2p4_ok and jnp.linalg.norm(p2 - p4) <= 2 * AGENT_RADIUS:
             assert bool(ts.encount[2, 4]), (p2, p3, p4)
             assert bool(ts.encount[4, 2]), (p2, p3, p4)
-            assert bool(ts.obs.collision[2, 0]), (p2, p3, p4)
-            assert bool(ts.obs.collision[4, 0]), (p2, p3, p4)
+            assert bool(ts.obs.collision[2, 0, -1]), (p2, p3, p4)
+            assert bool(ts.obs.collision[4, 0, 0]), (p2, p3, p4)
             p2p4_ok = True
 
         p3_to_food = jnp.linalg.norm(p3 - jnp.array([80.0, 90.0]))
         if not p3_ok and p3_to_food <= AGENT_RADIUS + FOOD_RADIUS:
-            assert bool(ts.obs.collision[3, 1]), (p2, p3, p4)
+            assert bool(ts.obs.collision[3, 1, 0]), (p2, p3, p4)
             p3_ok = True
 
         if p2p4_ok and p3_ok:
@@ -281,12 +281,12 @@ def test_collision_with_foodlabels(key: chex.PRNGKey) -> None:
         if jnp.any(ts.obs.collision):
             assert jnp.all(to_food <= AGENT_RADIUS + FOOD_RADIUS + 0.1)
             chex.assert_trees_all_close(
-                ts.obs.collision[:3],
+                ts.obs.collision[:3, :, -1],
                 jnp.array(
                     [
-                        [0.0, 1.0, 0.0, 0.0, 0.0],
-                        [0.0, 0.0, 1.0, 0.0, 0.0],
-                        [0.0, 0.0, 0.0, 1.0, 0.0],
+                        [False, True, False, False, False],
+                        [False, False, True, False, False],
+                        [False, False, False, True, False],
                     ]
                 ),
             )

From 4bf9d68e4a61333e69b157d1b95189660c84e17c Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 21 Mar 2024 16:08:00 +0900
Subject: [PATCH 334/337] Compute reward from n_ate_food instead of observation

---
 experiments/cf_simple.py                  | 13 ++++++-------
 src/emevo/environments/circle_foraging.py | 10 +++++-----
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/experiments/cf_simple.py b/experiments/cf_simple.py
index ea4fd584..28ce6468 100644
--- a/experiments/cf_simple.py
+++ b/experiments/cf_simple.py
@@ -59,27 +59,26 @@ def __post_init__(self) -> None:
 
     def normalize_action(self, action: jax.Array) -> jax.Array:
         scaled = self.act_space.sigmoid_scale(action)
-        norm = jnp.sqrt(jnp.sum(scaled**2, axis=-1))
+        norm = jnp.sqrt(jnp.sum(scaled**2, axis=-1, keepdims=True))
         return norm / self._max_norm
 
     def extract_linear(
         self,
-        collision: jax.Array,
+        ate_food: jax.Array,
         action: jax.Array,
         energy: jax.Array,
     ) -> jax.Array:
         del energy
         act_input = self.act_coef * self.normalize_action(action)
-        food_collision = collision[:, 1]
-        return jnp.stack((food_collision, act_input), axis=1)
+        return jnp.concatenate((ate_food.astype(jnp.float32), act_input), axis=1)
 
     def extract_sigmoid(
         self,
-        collision: jax.Array,
+        ate_food: jax.Array,
         action: jax.Array,
         energy: jax.Array,
     ) -> tuple[jax.Array, jax.Array]:
-        return self.extract_linear(collision, action, energy), energy
+        return self.extract_linear(ate_food, action, energy), energy
 
 
 def serialize_weight(w: jax.Array) -> dict[str, jax.Array]:
@@ -115,7 +114,7 @@ def step_rollout(
         )
         obs_t1 = timestep.obs
         energy = state_t.status.energy
-        rewards = reward_fn(obs_t1.collision, actions, energy).reshape(-1, 1)
+        rewards = reward_fn(timestep.info["n_ate_food"], actions, energy).reshape(-1, 1)
         rollout = Rollout(
             observations=obs_t_array,
             actions=actions,
diff --git a/src/emevo/environments/circle_foraging.py b/src/emevo/environments/circle_foraging.py
index 40e5f77a..4dc7f0a4 100644
--- a/src/emevo/environments/circle_foraging.py
+++ b/src/emevo/environments/circle_foraging.py
@@ -78,7 +78,7 @@ def as_array(self) -> jax.Array:
         return jnp.concatenate(
             (
                 self.sensor.reshape(self.sensor.shape[0], -1),
-                self.collision.reshape(self.collision.shape[0], -1),
+                self.collision.reshape(self.collision.shape[0], -1).astype(jnp.float32),
                 self.velocity,
                 jnp.expand_dims(self.angle, axis=1),
                 jnp.expand_dims(self.angular_velocity, axis=1),
@@ -208,8 +208,8 @@ def _make_physics(
     for _ in range(n_max_foods):
         builder.add_circle(
             radius=food_radius,
-            friction=0.1,
-            elasticity=0.1,
+            friction=0.2,
+            elasticity=0.4,
             color=FOOD_COLOR,
             is_static=True,
         )
@@ -670,7 +670,7 @@ def place_newborn_neighbor(
         self.obs_space = NamedTupleSpace(
             CFObs,
             sensor=BoxSpace(low=0.0, high=1.0, shape=(n_agent_sensors, self._n_obj)),
-            collision=BoxSpace(low=0.0, high=1.0, shape=(self._n_obj,)),
+            collision=BoxSpace(low=0.0, high=1.0, shape=(self._n_obj, n_tactile_bins)),
             velocity=BoxSpace(low=-MAX_VELOCITY, high=MAX_VELOCITY, shape=(2,)),
             angle=BoxSpace(low=-2 * np.pi, high=2 * np.pi, shape=()),
             angular_velocity=BoxSpace(low=-np.pi / 10, high=np.pi / 10, shape=()),
@@ -962,7 +962,7 @@ def reset(self, key: chex.PRNGKey) -> tuple[CFState, TimeStep[CFObs]]:
         sensor_obs = self._sensor_obs(stated=physics)
         obs = CFObs(
             sensor=sensor_obs.reshape(-1, self._n_sensors, self._n_obj),
-            collision=jnp.zeros((N, self._n_obj), dtype=bool),
+            collision=jnp.zeros((N, self._n_obj, self._n_tactile_bins), dtype=bool),
             angle=physics.circle.p.angle,
             velocity=physics.circle.v.xy,
             angular_velocity=physics.circle.v.angle,

From d01eabd3889ca7e36fb8262ed3131dbfbd70debf Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 21 Mar 2024 16:10:53 +0900
Subject: [PATCH 335/337] Don't assume sigmoid reward for now

---
 experiments/cf_asexual_evo.py | 793 ----------------------------------
 experiments/cf_simple.py      |  12 +-
 2 files changed, 2 insertions(+), 803 deletions(-)
 delete mode 100644 experiments/cf_asexual_evo.py

diff --git a/experiments/cf_asexual_evo.py b/experiments/cf_asexual_evo.py
deleted file mode 100644
index de97c0e4..00000000
--- a/experiments/cf_asexual_evo.py
+++ /dev/null
@@ -1,793 +0,0 @@
-"""Asexual reward evolution with Circle Foraging"""
-import dataclasses
-import enum
-import json
-from pathlib import Path
-from typing import Optional, cast
-
-import chex
-import equinox as eqx
-import jax
-import jax.numpy as jnp
-import numpy as np
-import optax
-import typer
-from serde import toml
-
-from emevo import Env
-from emevo import birth_and_death as bd
-from emevo import genetic_ops as gops
-from emevo import make
-from emevo import reward_fn as rfn
-from emevo.env import ObsProtocol as Obs
-from emevo.env import StateProtocol as State
-from emevo.eqx_utils import get_slice
-from emevo.eqx_utils import where as eqx_where
-from emevo.exp_utils import (
-    BDConfig,
-    CfConfig,
-    GopsConfig,
-    Log,
-    Logger,
-    LogMode,
-    SavedPhysicsState,
-    SavedProfile,
-)
-from emevo.rl.ppo_normal import (
-    NormalPPONet,
-    Rollout,
-    vmap_apply,
-    vmap_batch,
-    vmap_net,
-    vmap_update,
-    vmap_value,
-)
-from emevo.spaces import BoxSpace
-from emevo.visualizer import SaveVideoWrapper
-
-PROJECT_ROOT = Path(__file__).parent.parent
-
-
-class RewardKind(str, enum.Enum):
-    BOUNDED_EXP = "bounded-exp"
-    DELAYED_SE = "delayed-se"
-    LINEAR = "linear"
-    EXPONENTIAL = "exponential"
-    OFFSET_DELAYED_SBE = "offset-delayed-sbe"
-    OFFSET_DELAYED_SE = "offset-delayed-se"
-    OFFSET_DELAYED_SINH = "offset-delayed-sinh"
-    SIGMOID = "sigmoid"
-    SIGMOID_01 = "sigmoid-01"
-    SIGMOID_EXP = "sigmoid-exp"
-    SINH = "sinh"
-
-
-@dataclasses.dataclass
-class RewardExtractor:
-    act_space: BoxSpace
-    act_coef: float
-    mask: dataclasses.InitVar[str] = "1111"
-    _mask_array: jax.Array = dataclasses.field(init=False)
-    _max_norm: jax.Array = dataclasses.field(init=False)
-
-    def __post_init__(self, mask: str) -> None:
-        mask_array = jnp.array([x == "1" for x in mask])
-        self._mask_array = jnp.expand_dims(mask_array, axis=0)
-        self._max_norm = jnp.sqrt(
-            jnp.sum(self.act_space.high**2, axis=-1, keepdims=True)
-        )
-
-    def normalize_action(self, action: jax.Array) -> jax.Array:
-        scaled = self.act_space.sigmoid_scale(action)
-        norm = jnp.sqrt(jnp.sum(scaled**2, axis=-1, keepdims=True))
-        return norm / self._max_norm
-
-    def extract_linear(
-        self,
-        collision: jax.Array,
-        action: jax.Array,
-        energy: jax.Array,
-    ) -> jax.Array:
-        del energy
-        act_input = self.act_coef * self.normalize_action(action)
-        return jnp.concatenate((collision, act_input), axis=1) * self._mask_array
-
-    def extract_sigmoid(
-        self,
-        collision: jax.Array,
-        action: jax.Array,
-        energy: jax.Array,
-    ) -> tuple[jax.Array, jax.Array]:
-        act_input = self.act_coef * self.normalize_action(action)
-        reward_input = jnp.concatenate((collision, act_input), axis=1)
-        return reward_input * self._mask_array, energy
-
-
-def linear_rs(w: jax.Array) -> dict[str, jax.Array]:
-    return rfn.serialize_weight(w, ["agent", "food", "wall", "action"])
-
-
-def exp_rs(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
-    scale_dict = rfn.serialize_weight(
-        scale,
-        ["scale_agent", "scale_food", "scale_wall", "scale_action"],
-    )
-    return w_dict | scale_dict
-
-
-def sigmoid_rs(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
-    alpha_dict = rfn.serialize_weight(
-        alpha,
-        ["alpha_agent", "alpha_food", "alpha_wall", "alpha_action"],
-    )
-    return w_dict | alpha_dict
-
-
-def delayed_sigmoid_rs(w: jax.Array, delay: jax.Array) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
-    delay_dict = rfn.serialize_weight(
-        delay,
-        ["delay_agent", "delay_food", "delay_wall", "delay_action"],
-    )
-    return w_dict | delay_dict
-
-
-def sigmoid_exp_rs(
-    w: jax.Array,
-    scale: jax.Array,
-    alpha: jax.Array,
-) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
-    alpha_dict = rfn.serialize_weight(
-        alpha,
-        ["alpha_agent", "alpha_food", "alpha_wall", "alpha_action"],
-    )
-    scale_dict = rfn.serialize_weight(
-        scale,
-        ["scale_agent", "scale_food", "scale_wall", "scale_action"],
-    )
-    return (w_dict | alpha_dict) | scale_dict
-
-
-def delayed_se_rs(
-    w: jax.Array,
-    scale: jax.Array,
-    delay: jax.Array,
-) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(w, ["w_agent", "w_food", "w_wall", "w_action"])
-    delay_dict = rfn.serialize_weight(
-        delay,
-        ["delay_agent", "delay_food", "delay_wall", "delay_action"],
-    )
-    scale_dict = rfn.serialize_weight(
-        scale,
-        ["scale_agent", "scale_food", "scale_wall", "scale_action"],
-    )
-    return (w_dict | delay_dict) | scale_dict
-
-
-def linear_rs_withp(w: jax.Array) -> dict[str, jax.Array]:
-    return rfn.serialize_weight(w, ["agent", "food", "poison", "wall", "action"])
-
-
-def exp_rs_withp(w: jax.Array, scale: jax.Array) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(
-        w,
-        ["w_agent", "w_food", "w_poison", "w_wall", "w_action"],
-    )
-    scale_dict = rfn.serialize_weight(
-        scale,
-        ["scale_agent", "scale_food", "scale_poison", "scale_wall", "scale_action"],
-    )
-    return w_dict | scale_dict
-
-
-def sigmoid_rs_withp(w: jax.Array, alpha: jax.Array) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(
-        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
-    )
-    alpha_dict = rfn.serialize_weight(
-        alpha,
-        ["alpha_agent", "alpha_food", "alpha_poison", "alpha_wall", "alpha_action"],
-    )
-    return w_dict | alpha_dict
-
-
-def delayed_sigmoid_rs_withp(w: jax.Array, delay: jax.Array) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(
-        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
-    )
-    threshold_dict = rfn.serialize_weight(
-        delay,
-        [
-            "threshold_agent",
-            "threshold_food",
-            "threshold_poison",
-            "threshold_wall",
-            "threshold_action",
-        ],
-    )
-    return w_dict | threshold_dict
-
-
-def sigmoid_exp_rs_withp(
-    w: jax.Array, scale: jax.Array, alpha: jax.Array
-) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(
-        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
-    )
-    alpha_dict = rfn.serialize_weight(
-        alpha,
-        ["alpha_agent", "alpha_food", "alpha_poison", "alpha_wall", "alpha_action"],
-    )
-    scale_dict = rfn.serialize_weight(
-        scale,
-        ["scale_agent", "scale_food", "scale_poison", "scale_wall", "scale_action"],
-    )
-    return (w_dict | alpha_dict) | scale_dict
-
-
-def delayed_se_rs_withp(
-    w: jax.Array, scale: jax.Array, delay: jax.Array
-) -> dict[str, jax.Array]:
-    w_dict = rfn.serialize_weight(
-        w, ["w_agent", "w_food", "w_poison", "w_wall", "w_action"]
-    )
-    threshold_dict = rfn.serialize_weight(
-        delay,
-        [
-            "threshold_agent",
-            "threshold_food",
-            "threshold_poison",
-            "threshold_wall",
-            "threshold_action",
-        ],
-    )
-    scale_dict = rfn.serialize_weight(
-        scale,
-        ["scale_agent", "scale_food", "scale_poison", "scale_wall", "scale_action"],
-    )
-    return (w_dict | threshold_dict) | scale_dict
-
-
-def exec_rollout(
-    state: State,
-    initial_obs: Obs,
-    env: Env,
-    network: NormalPPONet,
-    reward_fn: rfn.RewardFn,
-    hazard_fn: bd.HazardFunction,
-    birth_fn: bd.BirthFunction,
-    prng_key: jax.Array,
-    n_rollout_steps: int,
-) -> tuple[State, Rollout, Log, SavedPhysicsState, Obs, jax.Array]:
-    def step_rollout(
-        carried: tuple[State, Obs],
-        key: jax.Array,
-    ) -> tuple[tuple[State, Obs], tuple[Rollout, Log, SavedPhysicsState]]:
-        act_key, hazard_key, birth_key = jax.random.split(key, 3)
-        state_t, obs_t = carried
-        obs_t_array = obs_t.as_array()
-        net_out = vmap_apply(network, obs_t_array)
-        actions = net_out.policy().sample(seed=act_key)
-        state_t1, timestep = env.step(
-            state_t,
-            env.act_space.sigmoid_scale(actions),  # type: ignore
-        )
-        obs_t1 = timestep.obs
-        energy = state_t.status.energy
-        rewards = reward_fn(obs_t1.collision, actions, energy).reshape(-1, 1)
-        rollout = Rollout(
-            observations=obs_t_array,
-            actions=actions,
-            rewards=rewards,
-            terminations=jnp.zeros_like(rewards),
-            values=net_out.value,
-            means=net_out.mean,
-            logstds=net_out.logstd,
-        )
-        # Birth and death
-        death_prob = hazard_fn(state_t1.status.age, state_t1.status.energy)
-        dead = jax.random.bernoulli(hazard_key, p=death_prob)
-        state_t1d = env.deactivate(state_t1, dead)
-        birth_prob = birth_fn(state_t1d.status.age, state_t1d.status.energy)
-        possible_parents = jnp.logical_and(
-            jnp.logical_and(
-                jnp.logical_not(dead),
-                state.unique_id.is_active(),  # type: ignore
-            ),
-            jax.random.bernoulli(birth_key, p=birth_prob),
-        )
-        state_t1db, parents = env.activate(state_t1d, possible_parents)
-        log = Log(
-            dead=jnp.where(dead, state_t.unique_id.unique_id, -1),  # type: ignore
-            got_food=obs_t1.collision[:, 1],
-            parents=parents,
-            rewards=rewards.ravel(),
-            energy=state_t1db.status.energy,
-            unique_id=state_t1db.unique_id.unique_id,
-            consumed_energy=timestep.info["energy_consumption"],
-        )
-        phys = state_t.physics  # type: ignore
-        phys_state = SavedPhysicsState(
-            circle_axy=phys.circle.p.into_axy(),
-            static_circle_axy=phys.static_circle.p.into_axy(),
-            circle_is_active=phys.circle.is_active,
-            static_circle_is_active=phys.static_circle.is_active,
-            static_circle_label=phys.static_circle.label,
-        )
-        return (state_t1db, obs_t1), (rollout, log, phys_state)
-
-    (state, obs), (rollout, log, phys_state) = jax.lax.scan(
-        step_rollout,
-        (state, initial_obs),
-        jax.random.split(prng_key, n_rollout_steps),
-    )
-    next_value = vmap_value(network, obs.as_array())
-    return state, rollout, log, phys_state, obs, next_value
-
-
-@eqx.filter_jit
-def epoch(
-    state: State,
-    initial_obs: Obs,
-    env: Env,
-    network: NormalPPONet,
-    reward_fn: rfn.RewardFn,
-    hazard_fn: bd.HazardFunction,
-    birth_fn: bd.BirthFunction,
-    prng_key: jax.Array,
-    n_rollout_steps: int,
-    gamma: float,
-    gae_lambda: float,
-    adam_update: optax.TransformUpdateFn,
-    opt_state: optax.OptState,
-    minibatch_size: int,
-    n_optim_epochs: int,
-) -> tuple[State, Obs, Log, SavedPhysicsState, optax.OptState, NormalPPONet]:
-    keys = jax.random.split(prng_key, env.n_max_agents + 1)
-    env_state, rollout, log, phys_state, obs, next_value = exec_rollout(
-        state,
-        initial_obs,
-        env,
-        network,
-        reward_fn,
-        hazard_fn,
-        birth_fn,
-        keys[0],
-        n_rollout_steps,
-    )
-    batch = vmap_batch(rollout, next_value, gamma, gae_lambda)
-    opt_state, pponet = vmap_update(
-        batch,
-        network,
-        adam_update,
-        opt_state,
-        keys[1:],
-        minibatch_size,
-        n_optim_epochs,
-        0.2,
-        0.0,
-    )
-    return env_state, obs, log, phys_state, opt_state, pponet
-
-
-def run_evolution(
-    *,
-    key: jax.Array,
-    env: Env,
-    n_initial_agents: int,
-    adam: optax.GradientTransformation,
-    gamma: float,
-    gae_lambda: float,
-    n_optim_epochs: int,
-    minibatch_size: int,
-    n_rollout_steps: int,
-    n_total_steps: int,
-    reward_fn: rfn.RewardFn,
-    hazard_fn: bd.HazardFunction,
-    birth_fn: bd.BirthFunction,
-    mutation: gops.Mutation,
-    xmax: float,
-    ymax: float,
-    logger: Logger,
-    debug_vis: bool,
-) -> None:
-    key, net_key, reset_key = jax.random.split(key, 3)
-    obs_space = env.obs_space.flatten()
-    input_size = np.prod(obs_space.shape)
-    act_size = np.prod(env.act_space.shape)
-
-    def initialize_net(key: chex.PRNGKey) -> NormalPPONet:
-        return vmap_net(
-            input_size,
-            64,
-            act_size,
-            jax.random.split(key, env.n_max_agents),
-        )
-
-    pponet = initialize_net(net_key)
-    adam_init, adam_update = adam
-
-    @eqx.filter_jit
-    def initialize_opt_state(net: eqx.Module) -> optax.OptState:
-        return jax.vmap(adam_init)(eqx.filter(net, eqx.is_array))
-
-    @eqx.filter_jit
-    def replace_net(
-        key: chex.PRNGKey,
-        flag: jax.Array,
-        pponet: NormalPPONet,
-        opt_state: optax.OptState,
-    ) -> tuple[NormalPPONet, optax.OptState]:
-        initialized = initialize_net(key)
-        pponet = eqx_where(flag, initialized, pponet)
-        opt_state = jax.tree_map(
-            lambda a, b: jnp.where(
-                jnp.expand_dims(flag, tuple(range(1, a.ndim))),
-                b,
-                a,
-            ),
-            opt_state,
-            initialize_opt_state(pponet),
-        )
-        return pponet, opt_state
-
-    opt_state = initialize_opt_state(pponet)
-    env_state, timestep = env.reset(reset_key)
-    obs = timestep.obs
-
-    if debug_vis:
-        visualizer = env.visualizer(env_state, figsize=(xmax * 2, ymax * 2))
-    else:
-        visualizer = None
-
-    for i in range(n_initial_agents):
-        logger.reward_fn_dict[i + 1] = get_slice(reward_fn, i)
-        logger.profile_dict[i + 1] = SavedProfile(0, 0, i + 1)
-
-    for i, key in enumerate(jax.random.split(key, n_total_steps // n_rollout_steps)):
-        epoch_key, init_key = jax.random.split(key)
-        env_state, obs, log, phys_state, opt_state, pponet = epoch(
-            env_state,
-            obs,
-            env,
-            pponet,
-            reward_fn,
-            hazard_fn,
-            birth_fn,
-            epoch_key,
-            n_rollout_steps,
-            gamma,
-            gae_lambda,
-            adam_update,
-            opt_state,
-            minibatch_size,
-            n_optim_epochs,
-        )
-
-        if visualizer is not None:
-            visualizer.render(env_state.physics)  # type: ignore
-            visualizer.show()
-        # Extinct?
-        n_active = jnp.sum(env_state.unique_id.is_active())  # type: ignore
-        if n_active == 0:
-            print(f"Extinct after {i + 1} epochs")
-            break
-
-        # Save network
-        log_with_step = log.with_step(i * n_rollout_steps)
-        log_death = log_with_step.filter_death()
-        logger.save_agents(pponet, log_death.dead, log_death.slots)
-        log_birth = log_with_step.filter_birth()
-        # Initialize network and adam state for new agents
-        is_new = jnp.zeros(env.n_max_agents, dtype=bool).at[log_birth.slots].set(True)
-        if jnp.any(is_new):
-            pponet, opt_state = replace_net(init_key, is_new, pponet, opt_state)
-
-        # Mutation
-        reward_fn = rfn.mutate_reward_fn(
-            key,
-            logger.reward_fn_dict,
-            reward_fn,
-            mutation,
-            log_birth.parents,
-            log_birth.unique_id,
-            log_birth.slots,
-        )
-        # Update profile
-        for step, uid, parent in zip(
-            log_birth.step,
-            log_birth.unique_id,
-            log_birth.parents,
-        ):
-            ui = uid.item()
-            logger.profile_dict[ui] = SavedProfile(step.item(), parent.item(), ui)
-
-        # Push log and physics state
-        logger.push_log(log_with_step.filter_active())
-        logger.push_physstate(phys_state)
-
-    # Save logs before exiting
-    logger.finalize()
-    is_active = env_state.unique_id.is_active()
-    logger.save_agents(
-        pponet,
-        env_state.unique_id.unique_id[is_active],
-        jnp.arange(len(is_active))[is_active],
-    )
-
-
-app = typer.Typer(pretty_exceptions_show_locals=False)
-
-
-@app.command()
-def evolve(
-    seed: int = 1,
-    n_agents: int = 20,
-    init_energy: float = 20.0,
-    action_cost: float = 0.0001,
-    mutation_prob: float = 0.2,
-    adam_lr: float = 3e-4,
-    adam_eps: float = 1e-7,
-    gamma: float = 0.999,
-    gae_lambda: float = 0.95,
-    n_optim_epochs: int = 10,
-    minibatch_size: int = 256,
-    n_rollout_steps: int = 1024,
-    n_total_steps: int = 1024 * 10000,
-    act_reward_coef: float = 0.001,
-    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
-    bdconfig_path: Path = PROJECT_ROOT / "config/bd/20230530-a035-e020.toml",
-    gopsconfig_path: Path = PROJECT_ROOT / "config/gops/20240111-mutation-0401.toml",
-    env_override: str = "",
-    birth_override: str = "",
-    hazard_override: str = "",
-    reward_mask: Optional[str] = None,
-    reward_fn: RewardKind = RewardKind.LINEAR,
-    logdir: Path = Path("./log"),
-    log_mode: LogMode = LogMode.FULL,
-    log_interval: int = 1000,
-    savestate_interval: int = 1000,
-    poison_reward: bool = False,
-    debug_vis: bool = False,
-) -> None:
-    # Load config
-    with cfconfig_path.open("r") as f:
-        cfconfig = toml.from_toml(CfConfig, f.read())
-    with bdconfig_path.open("r") as f:
-        bdconfig = toml.from_toml(BDConfig, f.read())
-    with gopsconfig_path.open("r") as f:
-        gopsconfig = toml.from_toml(GopsConfig, f.read())
-
-    # Apply overrides
-    cfconfig.apply_override(env_override)
-    bdconfig.apply_birth_override(birth_override)
-    bdconfig.apply_hazard_override(hazard_override)
-
-    if reward_mask is None:
-        if poison_reward:
-            reward_mask = "11111"
-        else:
-            reward_mask = "1111"
-
-    # Load models
-    birth_fn, hazard_fn = bdconfig.load_models()
-    mutation = gopsconfig.load_model()
-    # Override config
-    cfconfig.n_initial_agents = n_agents
-    cfconfig.init_energy = init_energy
-    cfconfig.force_energy_consumption = action_cost
-    gopsconfig.params["mutation_prob"] = mutation_prob
-    # Make env
-    env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
-    key, reward_key = jax.random.split(jax.random.PRNGKey(seed))
-    reward_extracor = RewardExtractor(
-        act_space=env.act_space,  # type: ignore
-        act_coef=act_reward_coef,
-        mask=reward_mask,
-    )
-    common_rewardfn_args = {
-        "key": reward_key,
-        "n_agents": cfconfig.n_max_agents,
-        "n_weights": 5 if poison_reward else 4,
-        "std": gopsconfig.init_std,
-        "mean": gopsconfig.init_mean,
-    }
-    common_rewardfn_args |= gopsconfig.init_kwargs
-    if reward_fn == RewardKind.LINEAR:
-        reward_fn_instance = rfn.LinearReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_linear,
-            serializer=linear_rs_withp if poison_reward else linear_rs,
-        )
-    elif reward_fn == RewardKind.EXPONENTIAL:
-        reward_fn_instance = rfn.ExponentialReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_linear,
-            serializer=exp_rs_withp if poison_reward else exp_rs,
-        )
-    elif reward_fn == RewardKind.BOUNDED_EXP:
-        reward_fn_instance = rfn.BoundedExponentialReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_linear,
-            serializer=exp_rs_withp if poison_reward else exp_rs,
-        )
-    elif reward_fn == RewardKind.SIGMOID:
-        reward_fn_instance = rfn.SigmoidReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=sigmoid_rs_withp if poison_reward else sigmoid_rs,
-        )
-    elif reward_fn == RewardKind.SIGMOID_01:
-        reward_fn_instance = rfn.SigmoidReward_01(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=sigmoid_rs_withp if poison_reward else sigmoid_rs,
-        )
-    elif reward_fn == RewardKind.SIGMOID_EXP:
-        reward_fn_instance = rfn.SigmoidExponentialReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=sigmoid_exp_rs_withp if poison_reward else sigmoid_exp_rs,
-        )
-    elif reward_fn == RewardKind.DELAYED_SE:
-        reward_fn_instance = rfn.DelayedSEReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=delayed_se_rs_withp if poison_reward else delayed_se_rs,
-        )
-    elif reward_fn == RewardKind.OFFSET_DELAYED_SBE:
-        reward_fn_instance = rfn.OffsetDelayedSBEReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=delayed_se_rs_withp if poison_reward else delayed_se_rs,
-        )
-    elif reward_fn == RewardKind.OFFSET_DELAYED_SE:
-        reward_fn_instance = rfn.OffsetDelayedSEReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=delayed_se_rs_withp if poison_reward else delayed_se_rs,
-        )
-    elif reward_fn == RewardKind.SINH:
-        reward_fn_instance = rfn.SinhReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_linear,
-            serializer=linear_rs_withp if poison_reward else linear_rs,
-        )
-    elif reward_fn == RewardKind.OFFSET_DELAYED_SINH:
-        reward_fn_instance = rfn.OffsetDelayedSinhReward(
-            **common_rewardfn_args,
-            extractor=reward_extracor.extract_sigmoid,
-            serializer=delayed_sigmoid_rs_withp
-            if poison_reward
-            else delayed_sigmoid_rs,
-        )
-    else:
-        raise ValueError(f"Invalid reward_fn {reward_fn}")
-
-    logger = Logger(
-        logdir=logdir,
-        mode=log_mode,
-        log_interval=log_interval,
-        savestate_interval=savestate_interval,
-    )
-    run_evolution(
-        key=key,
-        env=env,
-        n_initial_agents=n_agents,
-        adam=optax.adam(adam_lr, eps=adam_eps),
-        gamma=gamma,
-        gae_lambda=gae_lambda,
-        n_optim_epochs=n_optim_epochs,
-        minibatch_size=minibatch_size,
-        n_rollout_steps=n_rollout_steps,
-        n_total_steps=n_total_steps,
-        reward_fn=reward_fn_instance,
-        hazard_fn=hazard_fn,
-        birth_fn=birth_fn,
-        mutation=cast(gops.Mutation, mutation),
-        xmax=cfconfig.xlim[1],
-        ymax=cfconfig.ylim[1],
-        logger=logger,
-        debug_vis=debug_vis,
-    )
-
-
-@app.command()
-def replay(
-    physstate_path: Path,
-    backend: str = "pyglet",  # Use "headless" for headless rendering
-    videopath: Optional[Path] = None,
-    start: int = 0,
-    end: Optional[int] = None,
-    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
-    env_override: str = "",
-) -> None:
-    with cfconfig_path.open("r") as f:
-        cfconfig = toml.from_toml(CfConfig, f.read())
-    # For speedup
-    cfconfig.n_initial_agents = 1
-    cfconfig.apply_override(env_override)
-    phys_state = SavedPhysicsState.load(physstate_path)
-    env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
-    env_state, _ = env.reset(jax.random.PRNGKey(0))
-    end_index = end if end is not None else phys_state.circle_axy.shape[0]
-    visualizer = env.visualizer(
-        env_state,
-        figsize=(cfconfig.xlim[1] * 2, cfconfig.ylim[1] * 2),
-        backend=backend,
-    )
-    if videopath is not None:
-        visualizer = SaveVideoWrapper(visualizer, videopath, fps=60)
-    for i in range(start, end_index):
-        phys = phys_state.set_by_index(i, env_state.physics)
-        env_state = dataclasses.replace(env_state, physics=phys)
-        visualizer.render(env_state.physics)
-        visualizer.show()
-    visualizer.close()
-
-
-@app.command()
-def widget(
-    physstate_path: Path,
-    start: int = 0,
-    end: Optional[int] = None,
-    cfconfig_path: Path = PROJECT_ROOT / "config/env/20231214-square.toml",
-    log_path: Optional[Path] = None,
-    self_terminate: bool = False,
-    profile_and_rewards_path: Optional[Path] = None,
-    cm_fixed_minmax: str = "",
-    env_override: str = "",
-) -> None:
-    from emevo.analysis.qt_widget import CFEnvReplayWidget, start_widget
-
-    with cfconfig_path.open("r") as f:
-        cfconfig = toml.from_toml(CfConfig, f.read())
-    # For speedup
-    cfconfig.n_initial_agents = 1
-    cfconfig.apply_override(env_override)
-    phys_state = SavedPhysicsState.load(physstate_path)
-    env = make("CircleForaging-v0", **dataclasses.asdict(cfconfig))
-    end = phys_state.circle_axy.shape[0] if end is None else end
-    if log_path is None:
-        log_ds = None
-        step_offset = 0
-    else:
-        import pyarrow.dataset as ds
-
-        log_ds = ds.dataset(log_path)
-        step_offset = log_ds.scanner(columns=["step"]).head(1)["step"][0].as_py()
-
-    if profile_and_rewards_path is None:
-        profile_and_rewards = None
-    else:
-        import pyarrow.parquet as pq
-
-        profile_and_rewards = pq.read_table(profile_and_rewards_path)
-
-    if len(cm_fixed_minmax) > 0:
-        cm_fixed_minmax_dict = json.loads(cm_fixed_minmax)
-    else:
-        cm_fixed_minmax_dict = {}
-
-    start_widget(
-        CFEnvReplayWidget,
-        xlim=int(cfconfig.xlim[1]),
-        ylim=int(cfconfig.ylim[1]),
-        env=env,
-        saved_physics=phys_state,
-        start=start,
-        end=end,
-        log_ds=log_ds,
-        step_offset=step_offset,
-        self_terminate=self_terminate,
-        profile_and_rewards=profile_and_rewards,
-        cm_fixed_minmax=cm_fixed_minmax_dict,
-    )
-
-
-if __name__ == "__main__":
-    app()
diff --git a/experiments/cf_simple.py b/experiments/cf_simple.py
index 28ce6468..57985de4 100644
--- a/experiments/cf_simple.py
+++ b/experiments/cf_simple.py
@@ -62,7 +62,7 @@ def normalize_action(self, action: jax.Array) -> jax.Array:
         norm = jnp.sqrt(jnp.sum(scaled**2, axis=-1, keepdims=True))
         return norm / self._max_norm
 
-    def extract_linear(
+    def extract(
         self,
         ate_food: jax.Array,
         action: jax.Array,
@@ -72,14 +72,6 @@ def extract_linear(
         act_input = self.act_coef * self.normalize_action(action)
         return jnp.concatenate((ate_food.astype(jnp.float32), act_input), axis=1)
 
-    def extract_sigmoid(
-        self,
-        ate_food: jax.Array,
-        action: jax.Array,
-        energy: jax.Array,
-    ) -> tuple[jax.Array, jax.Array]:
-        return self.extract_linear(ate_food, action, energy), energy
-
 
 def serialize_weight(w: jax.Array) -> dict[str, jax.Array]:
     wd = w.shape[0]
@@ -429,7 +421,7 @@ def evolve(
         n_weights=1 + cfconfig.n_food_sources,
         std=gopsconfig.init_std,
         mean=gopsconfig.init_mean,
-        extractor=reward_extracor.extract_linear,
+        extractor=reward_extracor.extract,
         serializer=serialize_weight,
         **gopsconfig.init_kwargs,
     )

From 264d7c146582d0f7614adf6b7cf3ef92435e11cc Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 21 Mar 2024 17:35:38 +0900
Subject: [PATCH 336/337] Fix lint

---
 src/emevo/environments/cf_with_smell.py | 3 +--
 src/emevo/environments/env_utils.py     | 2 +-
 src/emevo/environments/phyjax2d.py      | 3 +--
 tests/test_smell.py                     | 1 -
 4 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/emevo/environments/cf_with_smell.py b/src/emevo/environments/cf_with_smell.py
index af90b939..77ba0d35 100644
--- a/src/emevo/environments/cf_with_smell.py
+++ b/src/emevo/environments/cf_with_smell.py
@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-from dataclasses import replace
-from typing import NamedTuple, overload
+from typing import NamedTuple
 
 import chex
 import jax
diff --git a/src/emevo/environments/env_utils.py b/src/emevo/environments/env_utils.py
index 8b9d7d20..f7a740ef 100644
--- a/src/emevo/environments/env_utils.py
+++ b/src/emevo/environments/env_utils.py
@@ -83,6 +83,7 @@ def __call__(self, _: int, state: FoodNumState) -> FoodNumState:
         dn_dt = self.growth_rate * internal * (1 - internal / self.capacity)
         return state._update(internal + dn_dt)
 
+
 class ReprNumCycle:
     def __init__(
         self,
@@ -111,7 +112,6 @@ def __call__(self, n_steps: int, state: FoodNumState) -> FoodNumState:
         return jax.lax.switch(index, self._numfn_list, n_steps, state)
 
 
-
 class ReprNumScheduled:
     """Branching based on steps."""
 
diff --git a/src/emevo/environments/phyjax2d.py b/src/emevo/environments/phyjax2d.py
index 547fb6b0..cde2f396 100644
--- a/src/emevo/environments/phyjax2d.py
+++ b/src/emevo/environments/phyjax2d.py
@@ -99,8 +99,7 @@ class _PositionLike(Protocol):
     angle: jax.Array  # Angular velocity (N,)
     xy: jax.Array  # (N, 2)
 
-    def __init__(self, angle: jax.Array, xy: jax.Array) -> None:
-        ...
+    def __init__(self, angle: jax.Array, xy: jax.Array) -> None: ...
 
     def batch_size(self) -> int:
         return self.angle.shape[0]
diff --git a/tests/test_smell.py b/tests/test_smell.py
index d7a7c3e5..c115e299 100644
--- a/tests/test_smell.py
+++ b/tests/test_smell.py
@@ -11,7 +11,6 @@
     CFSState,
     CircleForagingWithSmell,
     _compute_smell,
-    _vmap_compute_smell,
 )
 
 N_MAX_AGENTS = 10

From f798e2849ee391a184ed6db764df99a234c841f3 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Thu, 21 Mar 2024 17:40:05 +0900
Subject: [PATCH 337/337] Fix an isort error

---
 noxfile.py                         | 2 +-
 src/emevo/environments/__init__.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/noxfile.py b/noxfile.py
index 43469dd7..a4e69fdf 100644
--- a/noxfile.py
+++ b/noxfile.py
@@ -70,7 +70,7 @@ def format(session: nox.Session) -> None:
 @nox.session(reuse_venv=True, python=["3.9", "3.10", "3.11"])
 def lint(session: nox.Session) -> None:
     _sync(session, "requirements/lint.txt")
-    session.run("ruff", *SOURCES)
+    session.run("ruff", "check", *SOURCES)
     session.run("black", *SOURCES, "--check")
     session.run("isort", *SOURCES, "--check")
 
diff --git a/src/emevo/environments/__init__.py b/src/emevo/environments/__init__.py
index 4e1b8b70..be1bd1fa 100644
--- a/src/emevo/environments/__init__.py
+++ b/src/emevo/environments/__init__.py
@@ -1,8 +1,8 @@
 """ Implementation of registry and built-in emevo environments.
 """
 
-from emevo.environments.circle_foraging import CircleForaging
 from emevo.environments.cf_with_smell import CircleForagingWithSmell
+from emevo.environments.circle_foraging import CircleForaging
 from emevo.environments.registry import register
 
 register(