Add files using upload-large-folder tool

.gitattributes

@@ -1527,3 +1527,7 @@ janus/lib/liblsan.so filter=lfs diff=lfs merge=lfs -text
 janus/lib/libncursesw.so.6 filter=lfs diff=lfs merge=lfs -text
 janus/lib/libtsan.so.0.0.0 filter=lfs diff=lfs merge=lfs -text
 janus/lib/libtsan.so filter=lfs diff=lfs merge=lfs -text
+janus/lib/libstdc++.so.6.0.29 filter=lfs diff=lfs merge=lfs -text
+janus/lib/libasan.so.6.0.0 filter=lfs diff=lfs merge=lfs -text
+janus/lib/libssl.so filter=lfs diff=lfs merge=lfs -text
+janus/lib/libgcc_s.so.1 filter=lfs diff=lfs merge=lfs -text

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/actor_manager.py

@@ -0,0 +1,916 @@
+from collections import defaultdict
+import copy
+from dataclasses import dataclass
+import logging
+import sys
+import time
+from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Union
+
+import ray
+from ray.actor import ActorHandle
+from ray.exceptions import RayError, RayTaskError
+from ray.rllib.utils.typing import T
+from ray.util.annotations import DeveloperAPI
+
+
+logger = logging.getLogger(__name__)
+
+
+@DeveloperAPI
+class ResultOrError:
+    """A wrapper around a result or a RayError thrown during remote task/actor calls.
+
+    This is used to return data from `FaultTolerantActorManager` that allows us to
+    distinguish between RayErrors (remote actor related) and valid results.
+    """
+
+    def __init__(self, result: Any = None, error: Exception = None):
+        """One and only one of result or error should be set.
+
+        Args:
+            result: The result of the computation. Note that None is a valid result if
+                the remote function does not return anything.
+            error: Alternatively, the error that occurred during the computation.
+        """
+        self._result = result
+        self._error = (
+            # Easier to handle if we show the user the original error.
+            error.as_instanceof_cause()
+            if isinstance(error, RayTaskError)
+            else error
+        )
+
+    @property
+    def ok(self):
+        return self._error is None
+
+    def get(self):
+        """Returns the result or the error."""
+        if self._error:
+            return self._error
+        else:
+            return self._result
+
+
+@DeveloperAPI
+@dataclass
+class CallResult:
+    """Represents a single result from a call to an actor.
+
+    Each CallResult contains the index of the actor that was called
+    plus the result or error from the call.
+    """
+
+    actor_id: int
+    result_or_error: ResultOrError
+    tag: str
+
+    @property
+    def ok(self):
+        """Passes through the ok property from the result_or_error."""
+        return self.result_or_error.ok
+
+    def get(self):
+        """Passes through the get method from the result_or_error."""
+        return self.result_or_error.get()
+
+
+@DeveloperAPI
+class RemoteCallResults:
+    """Represents a list of results from calls to a set of actors.
+
+    CallResults provides convenient APIs to iterate over the results
+    while skipping errors, etc.
+
+    .. testcode::
+        :skipif: True
+
+        manager = FaultTolerantActorManager(
+            actors, max_remote_requests_in_flight_per_actor=2,
+        )
+        results = manager.foreach_actor(lambda w: w.call())
+
+        # Iterate over all results ignoring errors.
+        for result in results.ignore_errors():
+            print(result.get())
+    """
+
+    class _Iterator:
+        """An iterator over the results of a remote call."""
+
+        def __init__(self, call_results: List[CallResult]):
+            self._call_results = call_results
+
+        def __iter__(self) -> Iterator[CallResult]:
+            return self
+
+        def __next__(self) -> CallResult:
+            if not self._call_results:
+                raise StopIteration
+            return self._call_results.pop(0)
+
+    def __init__(self):
+        self.result_or_errors: List[CallResult] = []
+
+    def add_result(self, actor_id: int, result_or_error: ResultOrError, tag: str):
+        """Add index of a remote actor plus the call result to the list.
+
+        Args:
+            actor_id: ID of the remote actor.
+            result_or_error: The result or error from the call.
+            tag: A description to identify the call.
+        """
+        self.result_or_errors.append(CallResult(actor_id, result_or_error, tag))
+
+    def __iter__(self) -> Iterator[ResultOrError]:
+        """Return an iterator over the results."""
+        # Shallow copy the list.
+        return self._Iterator(copy.copy(self.result_or_errors))
+
+    def __len__(self) -> int:
+        return len(self.result_or_errors)
+
+    def ignore_errors(self) -> Iterator[ResultOrError]:
+        """Return an iterator over the results, skipping all errors."""
+        return self._Iterator([r for r in self.result_or_errors if r.ok])
+
+    def ignore_ray_errors(self) -> Iterator[ResultOrError]:
+        """Return an iterator over the results, skipping only Ray errors.
+
+        Similar to ignore_errors, but only skips Errors raised because of
+        remote actor problems (often get restored automatcially).
+        This is useful for callers that want to handle application errors differently
+        from Ray errors.
+        """
+        return self._Iterator(
+            [r for r in self.result_or_errors if not isinstance(r.get(), RayError)]
+        )
+
+
+@DeveloperAPI
+class FaultAwareApply:
+    @DeveloperAPI
+    def ping(self) -> str:
+        """Ping the actor. Can be used as a health check.
+
+        Returns:
+            "pong" if actor is up and well.
+        """
+        return "pong"
+
+    @DeveloperAPI
+    def apply(
+        self,
+        func: Callable[[Any, Optional[Any], Optional[Any]], T],
+        *args,
+        **kwargs,
+    ) -> T:
+        """Calls the given function with this Actor instance.
+
+        A generic interface for applying arbitrary member functions on a
+        remote actor.
+
+        Args:
+            func: The function to call, with this actor as first
+                argument, followed by args, and kwargs.
+            args: Optional additional args to pass to the function call.
+            kwargs: Optional additional kwargs to pass to the function call.
+
+        Returns:
+            The return value of the function call.
+        """
+        try:
+            return func(self, *args, **kwargs)
+        except Exception as e:
+            # Actor should be recreated by Ray.
+            if self.config.restart_failed_env_runners:
+                logger.exception(f"Worker exception caught during `apply()`: {e}")
+                # Small delay to allow logs messages to propagate.
+                time.sleep(self.config.delay_between_env_runner_restarts_s)
+                # Kill this worker so Ray Core can restart it.
+                sys.exit(1)
+            # Actor should be left dead.
+            else:
+                raise e
+
+
+@DeveloperAPI
+class FaultTolerantActorManager:
+    """A manager that is aware of the healthiness of remote actors.
+
+    .. testcode::
+
+        import time
+        import ray
+        from ray.rllib.utils.actor_manager import FaultTolerantActorManager
+
+        @ray.remote
+        class MyActor:
+            def apply(self, fn):
+                return fn(self)
+
+            def do_something(self):
+                return True
+
+        actors = [MyActor.remote() for _ in range(3)]
+        manager = FaultTolerantActorManager(
+            actors, max_remote_requests_in_flight_per_actor=2,
+        )
+
+        # Synchronous remote calls.
+        results = manager.foreach_actor(lambda actor: actor.do_something())
+        # Print results ignoring returned errors.
+        print([r.get() for r in results.ignore_errors()])
+
+        # Asynchronous remote calls.
+        manager.foreach_actor_async(lambda actor: actor.do_something())
+        time.sleep(2)  # Wait for the tasks to finish.
+        for r in manager.fetch_ready_async_reqs():
+            # Handle result and errors.
+            if r.ok:
+                print(r.get())
+            else:
+                print("Error: {}".format(r.get()))
+    """
+
+    @dataclass
+    class _ActorState:
+        """State of a single actor."""
+
+        # Num of outstanding async requests for this actor.
+        num_in_flight_async_requests: int = 0
+        # Whether this actor is in a healthy state.
+        is_healthy: bool = True
+
+    def __init__(
+        self,
+        actors: Optional[List[ActorHandle]] = None,
+        max_remote_requests_in_flight_per_actor: int = 2,
+        init_id: int = 0,
+    ):
+        """Construct a FaultTolerantActorManager.
+
+        Args:
+            actors: A list of ray remote actors to manage on. These actors must have an
+                ``apply`` method which takes a function with only one parameter (the
+                actor instance itself).
+            max_remote_requests_in_flight_per_actor: The maximum number of remote
+                requests that can be in flight per actor. Any requests made to the pool
+                that cannot be scheduled because the limit has been reached will be
+                dropped. This only applies to the asynchronous remote call mode.
+            init_id: The initial ID to use for the next remote actor. Default is 0.
+        """
+        # For historic reasons, just start remote worker ID from 1, so they never
+        # collide with local worker ID (0).
+        self._next_id = init_id
+
+        # Actors are stored in a map and indexed by a unique (int) ID.
+        self._actors: Dict[int, ActorHandle] = {}
+        self._remote_actor_states: Dict[int, self._ActorState] = {}
+        self._restored_actors = set()
+        self.add_actors(actors or [])
+
+        # Maps outstanding async requests to the IDs of the actor IDs that
+        # are executing them.
+        self._in_flight_req_to_actor_id: Dict[ray.ObjectRef, int] = {}
+
+        self._max_remote_requests_in_flight_per_actor = (
+            max_remote_requests_in_flight_per_actor
+        )
+
+        # Useful metric.
+        self._num_actor_restarts = 0
+
+    @DeveloperAPI
+    def actor_ids(self) -> List[int]:
+        """Returns a list of all worker IDs (healthy or not)."""
+        return list(self._actors.keys())
+
+    @DeveloperAPI
+    def healthy_actor_ids(self) -> List[int]:
+        """Returns a list of worker IDs that are healthy."""
+        return [k for k, v in self._remote_actor_states.items() if v.is_healthy]
+
+    @DeveloperAPI
+    def add_actors(self, actors: List[ActorHandle]):
+        """Add a list of actors to the pool.
+
+        Args:
+            actors: A list of ray remote actors to be added to the pool.
+        """
+        for actor in actors:
+            self._actors[self._next_id] = actor
+            self._remote_actor_states[self._next_id] = self._ActorState()
+            self._next_id += 1
+
+    @DeveloperAPI
+    def remove_actor(self, actor_id: int) -> ActorHandle:
+        """Remove an actor from the pool.
+
+        Args:
+            actor_id: ID of the actor to remove.
+
+        Returns:
+            Handle to the actor that was removed.
+        """
+        actor = self._actors[actor_id]
+
+        # Remove the actor from the pool.
+        del self._actors[actor_id]
+        del self._remote_actor_states[actor_id]
+        self._restored_actors.discard(actor_id)
+        self._remove_async_state(actor_id)
+
+        return actor
+
+    @DeveloperAPI
+    def num_actors(self) -> int:
+        """Return the total number of actors in the pool."""
+        return len(self._actors)
+
+    @DeveloperAPI
+    def num_healthy_actors(self) -> int:
+        """Return the number of healthy remote actors."""
+        return sum(s.is_healthy for s in self._remote_actor_states.values())
+
+    @DeveloperAPI
+    def total_num_restarts(self) -> int:
+        """Return the number of remote actors that have been restarted."""
+        return self._num_actor_restarts
+
+    @DeveloperAPI
+    def num_outstanding_async_reqs(self) -> int:
+        """Return the number of outstanding async requests."""
+        return len(self._in_flight_req_to_actor_id)
+
+    @DeveloperAPI
+    def is_actor_healthy(self, actor_id: int) -> bool:
+        """Whether a remote actor is in healthy state.
+
+        Args:
+            actor_id: ID of the remote actor.
+
+        Returns:
+            True if the actor is healthy, False otherwise.
+        """
+        if actor_id not in self._remote_actor_states:
+            raise ValueError(f"Unknown actor id: {actor_id}")
+        return self._remote_actor_states[actor_id].is_healthy
+
+    @DeveloperAPI
+    def set_actor_state(self, actor_id: int, healthy: bool) -> None:
+        """Update activate state for a specific remote actor.
+
+        Args:
+            actor_id: ID of the remote actor.
+            healthy: Whether the remote actor is healthy.
+        """
+        if actor_id not in self._remote_actor_states:
+            raise ValueError(f"Unknown actor id: {actor_id}")
+
+        was_healthy = self._remote_actor_states[actor_id].is_healthy
+        # Set from unhealthy to healthy -> Add to restored set.
+        if not was_healthy and healthy:
+            self._restored_actors.add(actor_id)
+        # Set from healthy to unhealthy -> Remove from restored set.
+        elif was_healthy and not healthy:
+            self._restored_actors.discard(actor_id)
+
+        self._remote_actor_states[actor_id].is_healthy = healthy
+
+        if not healthy:
+            # Remove any async states.
+            self._remove_async_state(actor_id)
+
+    @DeveloperAPI
+    def clear(self):
+        """Clean up managed actors."""
+        for actor in self._actors.values():
+            ray.kill(actor)
+        self._actors.clear()
+        self._remote_actor_states.clear()
+        self._restored_actors.clear()
+        self._in_flight_req_to_actor_id.clear()
+
+    @DeveloperAPI
+    def foreach_actor(
+        self,
+        func: Union[Callable[[Any], Any], List[Callable[[Any], Any]]],
+        *,
+        healthy_only: bool = True,
+        remote_actor_ids: Optional[List[int]] = None,
+        timeout_seconds: Optional[float] = None,
+        return_obj_refs: bool = False,
+        mark_healthy: bool = False,
+    ) -> RemoteCallResults:
+        """Calls the given function with each actor instance as arg.
+
+        Automatically marks actors unhealthy if they crash during the remote call.
+
+        Args:
+            func: A single, or a list of Callables, that get applied on the list
+                of specified remote actors.
+            healthy_only: If True, applies `func` only to actors currently tagged
+                "healthy", otherwise to all actors. If `healthy_only=False` and
+                `mark_healthy=True`, will send `func` to all actors and mark those
+                actors "healthy" that respond to the request within `timeout_seconds`
+                and are currently tagged as "unhealthy".
+            remote_actor_ids: Apply func on a selected set of remote actors. Use None
+                (default) for all actors.
+            timeout_seconds: Time to wait (in seconds) for results. Set this to 0.0 for
+                fire-and-forget. Set this to None (default) to wait infinitely (i.e. for
+                synchronous execution).
+            return_obj_refs: whether to return ObjectRef instead of actual results.
+                Note, for fault tolerance reasons, these returned ObjectRefs should
+                never be resolved with ray.get() outside of the context of this manager.
+            mark_healthy: Whether to mark all those actors healthy again that are
+                currently marked unhealthy AND that returned results from the remote
+                call (within the given `timeout_seconds`).
+                Note that actors are NOT set unhealthy, if they simply time out
+                (only if they return a RayActorError).
+                Also not that this setting is ignored if `healthy_only=True` (b/c this
+                setting only affects actors that are currently tagged as unhealthy).
+
+        Returns:
+            The list of return values of all calls to `func(actor)`. The values may be
+            actual data returned or exceptions raised during the remote call in the
+            format of RemoteCallResults.
+        """
+        remote_actor_ids = remote_actor_ids or self.actor_ids()
+        if healthy_only:
+            func, remote_actor_ids = self._filter_func_and_remote_actor_id_by_state(
+                func, remote_actor_ids
+            )
+
+        # Send out remote requests.
+        remote_calls = self._call_actors(
+            func=func,
+            remote_actor_ids=remote_actor_ids,
+        )
+
+        # Collect remote request results (if available given timeout and/or errors).
+        _, remote_results = self._fetch_result(
+            remote_actor_ids=remote_actor_ids,
+            remote_calls=remote_calls,
+            tags=[None] * len(remote_calls),
+            timeout_seconds=timeout_seconds,
+            return_obj_refs=return_obj_refs,
+            mark_healthy=mark_healthy,
+        )
+
+        return remote_results
+
+    @DeveloperAPI
+    def foreach_actor_async(
+        self,
+        func: Union[Callable[[Any], Any], List[Callable[[Any], Any]]],
+        tag: str = None,
+        *,
+        healthy_only: bool = True,
+        remote_actor_ids: List[int] = None,
+    ) -> int:
+        """Calls given functions against each actors without waiting for results.
+
+        Args:
+            func: A single Callable applied to all specified remote actors or a list
+                of Callables, that get applied on the list of specified remote actors.
+                In the latter case, both list of Callables and list of specified actors
+                must have the same length.
+            tag: A tag to identify the results from this async call.
+            healthy_only: If True, applies `func` only to actors currently tagged
+                "healthy", otherwise to all actors. If `healthy_only=False` and
+                later, `self.fetch_ready_async_reqs()` is called with
+                `mark_healthy=True`, will send `func` to all actors and mark those
+                actors "healthy" that respond to the request within `timeout_seconds`
+                and are currently tagged as "unhealthy".
+            remote_actor_ids: Apply func on a selected set of remote actors.
+                Note, for fault tolerance reasons, these returned ObjectRefs should
+                never be resolved with ray.get() outside of the context of this manager.
+
+        Returns:
+            The number of async requests that are actually fired.
+        """
+        # TODO(avnishn, jungong): so thinking about this a bit more, it would be the
+        #  best if we can attach multiple tags to an async all, like basically this
+        #  parameter should be tags:
+        #  For sync calls, tags would be ().
+        #  For async call users, they can attached multiple tags for a single call, like
+        #  ("rollout_worker", "sync_weight").
+        #  For async fetch result, we can also specify a single, or list of tags. For
+        #  example, ("eval", "sample") will fetch all the sample() calls on eval
+        #  workers.
+        remote_actor_ids = remote_actor_ids or self.actor_ids()
+
+        if healthy_only:
+            func, remote_actor_ids = self._filter_func_and_remote_actor_id_by_state(
+                func, remote_actor_ids
+            )
+
+        if isinstance(func, list) and len(func) != len(remote_actor_ids):
+            raise ValueError(
+                f"The number of functions specified {len(func)} must match "
+                f"the number of remote actor indices {len(remote_actor_ids)}."
+            )
+
+        num_calls_to_make: Dict[int, int] = defaultdict(lambda: 0)
+        # Drop calls to actors that are too busy.
+        if isinstance(func, list):
+            limited_func = []
+            limited_remote_actor_ids = []
+            for i, f in zip(remote_actor_ids, func):
+                num_outstanding_reqs = self._remote_actor_states[
+                    i
+                ].num_in_flight_async_requests
+                if (
+                    num_outstanding_reqs + num_calls_to_make[i]
+                    < self._max_remote_requests_in_flight_per_actor
+                ):
+                    num_calls_to_make[i] += 1
+                    limited_func.append(f)
+                    limited_remote_actor_ids.append(i)
+        else:
+            limited_func = func
+            limited_remote_actor_ids = []
+            for i in remote_actor_ids:
+                num_outstanding_reqs = self._remote_actor_states[
+                    i
+                ].num_in_flight_async_requests
+                if (
+                    num_outstanding_reqs + num_calls_to_make[i]
+                    < self._max_remote_requests_in_flight_per_actor
+                ):
+                    num_calls_to_make[i] += 1
+                    limited_remote_actor_ids.append(i)
+
+        remote_calls = self._call_actors(
+            func=limited_func,
+            remote_actor_ids=limited_remote_actor_ids,
+        )
+
+        # Save these as outstanding requests.
+        for id, call in zip(limited_remote_actor_ids, remote_calls):
+            self._remote_actor_states[id].num_in_flight_async_requests += 1
+            self._in_flight_req_to_actor_id[call] = (tag, id)
+
+        return len(remote_calls)
+
+    @DeveloperAPI
+    def fetch_ready_async_reqs(
+        self,
+        *,
+        tags: Union[str, List[str], Tuple[str]] = (),
+        timeout_seconds: Optional[float] = 0.0,
+        return_obj_refs: bool = False,
+        mark_healthy: bool = False,
+    ) -> RemoteCallResults:
+        """Get results from outstanding async requests that are ready.
+
+        Automatically mark actors unhealthy if they fail to respond.
+
+        Note: If tags is an empty tuple then results from all ready async requests are
+        returned.
+
+        Args:
+            timeout_seconds: ray.get() timeout. Default is 0, which only fetched those
+                results (immediately) that are already ready.
+            tags: A tag or a list of tags to identify the results from this async call.
+            return_obj_refs: Whether to return ObjectRef instead of actual results.
+            mark_healthy: Whether to mark all those actors healthy again that are
+                currently marked unhealthy AND that returned results from the remote
+                call (within the given `timeout_seconds`).
+                Note that actors are NOT set to unhealthy, if they simply time out,
+                meaning take a longer time to fulfil the remote request. We only ever
+                mark an actor unhealthy, if they raise a RayActorError inside the remote
+                request.
+                Also note that this settings is ignored if the preceding
+                `foreach_actor_async()` call used the `healthy_only=True` argument (b/c
+                `mark_healthy` only affects actors that are currently tagged as
+                unhealthy).
+
+        Returns:
+            A list of return values of all calls to `func(actor)` that are ready.
+            The values may be actual data returned or exceptions raised during the
+            remote call in the format of RemoteCallResults.
+        """
+        # Construct the list of in-flight requests filtered by tag.
+        remote_calls, remote_actor_ids, valid_tags = self._filter_calls_by_tag(tags)
+        ready, remote_results = self._fetch_result(
+            remote_actor_ids=remote_actor_ids,
+            remote_calls=remote_calls,
+            tags=valid_tags,
+            timeout_seconds=timeout_seconds,
+            return_obj_refs=return_obj_refs,
+            mark_healthy=mark_healthy,
+        )
+
+        for obj_ref, result in zip(ready, remote_results):
+            # Decrease outstanding request on this actor by 1.
+            self._remote_actor_states[result.actor_id].num_in_flight_async_requests -= 1
+            # Also, remove this call here from the in-flight list,
+            # obj_refs may have already been removed when we disable an actor.
+            if obj_ref in self._in_flight_req_to_actor_id:
+                del self._in_flight_req_to_actor_id[obj_ref]
+
+        return remote_results
+
+    @staticmethod
+    def handle_remote_call_result_errors(
+        results_or_errors: RemoteCallResults,
+        *,
+        ignore_ray_errors: bool,
+    ) -> None:
+        """Checks given results for application errors and raises them if necessary.
+
+        Args:
+            results_or_errors: The results or errors to check.
+            ignore_ray_errors: Whether to ignore RayErrors within the elements of
+                `results_or_errors`.
+        """
+        for result_or_error in results_or_errors:
+            # Good result.
+            if result_or_error.ok:
+                continue
+            # RayError, but we ignore it.
+            elif ignore_ray_errors:
+                logger.exception(result_or_error.get())
+            # Raise RayError.
+            else:
+                raise result_or_error.get()
+
+    @DeveloperAPI
+    def probe_unhealthy_actors(
+        self,
+        timeout_seconds: Optional[float] = None,
+        mark_healthy: bool = False,
+    ) -> List[int]:
+        """Ping all unhealthy actors to try bringing them back.
+
+        Args:
+            timeout_seconds: Timeout in seconds (to avoid pinging hanging workers
+                indefinitely).
+            mark_healthy: Whether to mark all those actors healthy again that are
+                currently marked unhealthy AND that respond to the `ping` remote request
+                (within the given `timeout_seconds`).
+                Note that actors are NOT set to unhealthy, if they simply time out,
+                meaning take a longer time to fulfil the remote request. We only ever
+                mark and actor unhealthy, if they return a RayActorError from the remote
+                request.
+                Also note that this settings is ignored if `healthy_only=True` (b/c this
+                setting only affects actors that are currently tagged as unhealthy).
+
+        Returns:
+            A list of actor IDs that were restored by the `ping.remote()` call PLUS
+            those actors that were previously restored via other remote requests.
+            The cached set of such previously restored actors will be erased in this
+            call.
+        """
+        # Collect recently restored actors (from `self._fetch_result` calls other than
+        # the one triggered here via the `ping`).
+        restored_actors = list(self._restored_actors)
+        self._restored_actors.clear()
+
+        # Probe all unhealthy actors via a simple `ping()`.
+        unhealthy_actor_ids = [
+            actor_id
+            for actor_id in self.actor_ids()
+            if not self.is_actor_healthy(actor_id)
+        ]
+        # No unhealthy actors currently -> Return recently restored ones.
+        if not unhealthy_actor_ids:
+            return restored_actors
+
+        # Some unhealthy actors -> `ping()` all of them to trigger a new fetch and
+        # capture all restored ones.
+        remote_results = self.foreach_actor(
+            func=lambda actor: actor.ping(),
+            remote_actor_ids=unhealthy_actor_ids,
+            healthy_only=False,  # We specifically want to ping unhealthy actors.
+            timeout_seconds=timeout_seconds,
+            mark_healthy=mark_healthy,
+        )
+
+        # Return previously restored actors AND actors restored via the `ping()` call.
+        return restored_actors + [
+            result.actor_id for result in remote_results if result.ok
+        ]
+
+    def _call_actors(
+        self,
+        func: Union[Callable[[Any], Any], List[Callable[[Any], Any]]],
+        *,
+        remote_actor_ids: List[int] = None,
+    ) -> List[ray.ObjectRef]:
+        """Apply functions on a list of remote actors.
+
+        Args:
+            func: A single, or a list of Callables, that get applied on the list
+                of specified remote actors.
+            remote_actor_ids: Apply func on this selected set of remote actors.
+
+        Returns:
+            A list of ObjectRefs returned from the remote calls.
+        """
+        if isinstance(func, list):
+            assert len(remote_actor_ids) == len(
+                func
+            ), "Funcs must have the same number of callables as actor indices."
+
+        if remote_actor_ids is None:
+            remote_actor_ids = self.actor_ids()
+
+        if isinstance(func, list):
+            calls = [
+                self._actors[i].apply.remote(f) for i, f in zip(remote_actor_ids, func)
+            ]
+        else:
+            calls = [self._actors[i].apply.remote(func) for i in remote_actor_ids]
+
+        return calls
+
+    @DeveloperAPI
+    def _fetch_result(
+        self,
+        *,
+        remote_actor_ids: List[int],
+        remote_calls: List[ray.ObjectRef],
+        tags: List[str],
+        timeout_seconds: Optional[float] = None,
+        return_obj_refs: bool = False,
+        mark_healthy: bool = False,
+    ) -> Tuple[List[ray.ObjectRef], RemoteCallResults]:
+        """Try fetching results from remote actor calls.
+
+        Mark whether an actor is healthy or not accordingly.
+
+        Args:
+            remote_actor_ids: IDs of the actors these remote
+                calls were fired against.
+            remote_calls: List of remote calls to fetch.
+            tags: List of tags used for identifying the remote calls.
+            timeout_seconds: Timeout (in sec) for the ray.wait() call. Default is None,
+                meaning wait indefinitely for all results.
+            return_obj_refs: Whether to return ObjectRef instead of actual results.
+            mark_healthy: Whether to mark certain actors healthy based on the results
+                of these remote calls. Useful, for example, to make sure actors
+                do not come back without proper state restoration.
+
+        Returns:
+            A list of ready ObjectRefs mapping to the results of those calls.
+        """
+        # Notice that we do not return the refs to any unfinished calls to the
+        # user, since it is not safe to handle such remote actor calls outside the
+        # context of this actor manager. These requests are simply dropped.
+        timeout = float(timeout_seconds) if timeout_seconds is not None else None
+
+        # This avoids calling ray.init() in the case of 0 remote calls.
+        # This is useful if the number of remote workers is 0.
+        if not remote_calls:
+            return [], RemoteCallResults()
+
+        readies, _ = ray.wait(
+            remote_calls,
+            num_returns=len(remote_calls),
+            timeout=timeout,
+            # Make sure remote results are fetched locally in parallel.
+            fetch_local=not return_obj_refs,
+        )
+
+        # Remote data should already be fetched to local object store at this point.
+        remote_results = RemoteCallResults()
+        for ready in readies:
+            # Find the corresponding actor ID for this remote call.
+            actor_id = remote_actor_ids[remote_calls.index(ready)]
+            tag = tags[remote_calls.index(ready)]
+
+            # If caller wants ObjectRefs, return directly without resolving.
+            if return_obj_refs:
+                remote_results.add_result(actor_id, ResultOrError(result=ready), tag)
+                continue
+
+            # Try getting the ready results.
+            try:
+                result = ray.get(ready)
+
+            # Any error type other than `RayError` happening during ray.get() ->
+            # Throw exception right here (we don't know how to handle these non-remote
+            # worker issues and should therefore crash).
+            except RayError as e:
+                # Return error to the user.
+                remote_results.add_result(actor_id, ResultOrError(error=e), tag)
+
+                # Mark the actor as unhealthy, take it out of service, and wait for
+                # Ray Core to restore it.
+                if self.is_actor_healthy(actor_id):
+                    logger.error(
+                        f"Ray error ({str(e)}), taking actor {actor_id} out of service."
+                    )
+                self.set_actor_state(actor_id, healthy=False)
+
+            # If no errors, add result to `RemoteCallResults` to be returned.
+            else:
+                # Return valid result to the user.
+                remote_results.add_result(actor_id, ResultOrError(result=result), tag)
+
+                # Actor came back from an unhealthy state. Mark this actor as healthy
+                # and add it to our healthy set.
+                if mark_healthy and not self.is_actor_healthy(actor_id):
+                    logger.warning(
+                        f"Bringing previously unhealthy, now-healthy actor {actor_id} "
+                        "back into service."
+                    )
+                    self.set_actor_state(actor_id, healthy=True)
+                    self._num_actor_restarts += 1
+
+        # Make sure, to-be-returned results are sound.
+        assert len(readies) == len(remote_results)
+
+        return readies, remote_results
+
+    def _filter_func_and_remote_actor_id_by_state(
+        self,
+        func: Union[Callable[[Any], Any], List[Callable[[Any], Any]]],
+        remote_actor_ids: List[int],
+    ):
+        """Filter out func and remote worker ids by actor state.
+
+        Args:
+            func: A single, or a list of Callables.
+            remote_actor_ids: IDs of potential remote workers to apply func on.
+
+        Returns:
+            A tuple of (filtered func, filtered remote worker ids).
+        """
+        if isinstance(func, list):
+            assert len(remote_actor_ids) == len(
+                func
+            ), "Func must have the same number of callables as remote actor ids."
+            # We are given a list of functions to apply.
+            # Need to filter the functions together with worker IDs.
+            temp_func = []
+            temp_remote_actor_ids = []
+            for f, i in zip(func, remote_actor_ids):
+                if self.is_actor_healthy(i):
+                    temp_func.append(f)
+                    temp_remote_actor_ids.append(i)
+            func = temp_func
+            remote_actor_ids = temp_remote_actor_ids
+        else:
+            # Simply filter the worker IDs.
+            remote_actor_ids = [i for i in remote_actor_ids if self.is_actor_healthy(i)]
+
+        return func, remote_actor_ids
+
+    def _filter_calls_by_tag(
+        self, tags: Union[str, List[str], Tuple[str]]
+    ) -> Tuple[List[ray.ObjectRef], List[ActorHandle], List[str]]:
+        """Return all the in flight requests that match the given tags, if any.
+
+        Args:
+            tags: A str or a list/tuple of str. If tags is empty, return all the in
+                flight requests.
+
+        Returns:
+            A tuple consisting of a list of the remote calls that match the tag(s),
+            a list of the corresponding remote actor IDs for these calls (same length),
+            and a list of the tags corresponding to these calls (same length).
+        """
+        if isinstance(tags, str):
+            tags = {tags}
+        elif isinstance(tags, (list, tuple)):
+            tags = set(tags)
+        else:
+            raise ValueError(
+                f"tags must be either a str or a list/tuple of str, got {type(tags)}."
+            )
+        remote_calls = []
+        remote_actor_ids = []
+        valid_tags = []
+        for call, (tag, actor_id) in self._in_flight_req_to_actor_id.items():
+            # the default behavior is to return all ready results.
+            if len(tags) == 0 or tag in tags:
+                remote_calls.append(call)
+                remote_actor_ids.append(actor_id)
+                valid_tags.append(tag)
+
+        return remote_calls, remote_actor_ids, valid_tags
+
+    def _remove_async_state(self, actor_id: int):
+        """Remove internal async state of for a given actor.
+
+        This is called when an actor is removed from the pool or being marked
+        unhealthy.
+
+        Args:
+            actor_id: The id of the actor.
+        """
+        # Remove any outstanding async requests for this actor.
+        # Use `list` here to not change a looped generator while we mutate the
+        # underlying dict.
+        for id, req in list(self._in_flight_req_to_actor_id.items()):
+            if id == actor_id:
+                del self._in_flight_req_to_actor_id[req]
+
+    def actors(self):
+        # TODO(jungong) : remove this API once EnvRunnerGroup.remote_workers()
+        #  and EnvRunnerGroup._remote_workers() are removed.
+        return self._actors

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/annotations.py

@@ -0,0 +1,213 @@
+from ray.rllib.utils.deprecation import Deprecated
+from ray.util.annotations import _mark_annotated
+
+
+def override(parent_cls):
+    """Decorator for documenting method overrides.
+
+    Args:
+        parent_cls: The superclass that provides the overridden method. If
+            `parent_class` does not actually have the method or the class, in which
+            method is defined is not a subclass of `parent_class`, an error is raised.
+
+    .. testcode::
+        :skipif: True
+
+        from ray.rllib.policy import Policy
+        class TorchPolicy(Policy):
+            ...
+            # Indicates that `TorchPolicy.loss()` overrides the parent
+            # Policy class' own `loss method. Leads to an error if Policy
+            # does not have a `loss` method.
+
+            @override(Policy)
+            def loss(self, model, action_dist, train_batch):
+                ...
+
+    """
+
+    class OverrideCheck:
+        def __init__(self, func, expected_parent_cls):
+            self.func = func
+            self.expected_parent_cls = expected_parent_cls
+
+        def __set_name__(self, owner, name):
+            # Check if the owner (the class) is a subclass of the expected base class
+            if not issubclass(owner, self.expected_parent_cls):
+                raise TypeError(
+                    f"When using the @override decorator, {owner.__name__} must be a "
+                    f"subclass of {parent_cls.__name__}!"
+                )
+            # Set the function as a regular method on the class.
+            setattr(owner, name, self.func)
+
+    def decorator(method):
+        # Check, whether `method` is actually defined by the parent class.
+        if method.__name__ not in dir(parent_cls):
+            raise NameError(
+                f"When using the @override decorator, {method.__name__} must override "
+                f"the respective method (with the same name) of {parent_cls.__name__}!"
+            )
+
+        # Check if the class is a subclass of the expected base class
+        OverrideCheck(method, parent_cls)
+        return method
+
+    return decorator
+
+
+def PublicAPI(obj):
+    """Decorator for documenting public APIs.
+
+    Public APIs are classes and methods exposed to end users of RLlib. You
+    can expect these APIs to remain stable across RLlib releases.
+
+    Subclasses that inherit from a ``@PublicAPI`` base class can be
+    assumed part of the RLlib public API as well (e.g., all Algorithm classes
+    are in public API because Algorithm is ``@PublicAPI``).
+
+    In addition, you can assume all algo configurations are part of their
+    public API as well.
+
+    .. testcode::
+        :skipif: True
+
+        # Indicates that the `Algorithm` class is exposed to end users
+        # of RLlib and will remain stable across RLlib releases.
+        from ray import tune
+        @PublicAPI
+        class Algorithm(tune.Trainable):
+            ...
+    """
+
+    _mark_annotated(obj)
+    return obj
+
+
+def DeveloperAPI(obj):
+    """Decorator for documenting developer APIs.
+
+    Developer APIs are classes and methods explicitly exposed to developers
+    for the purposes of building custom algorithms or advanced training
+    strategies on top of RLlib internals. You can generally expect these APIs
+    to be stable sans minor changes (but less stable than public APIs).
+
+    Subclasses that inherit from a ``@DeveloperAPI`` base class can be
+    assumed part of the RLlib developer API as well.
+
+    .. testcode::
+        :skipif: True
+
+        # Indicates that the `TorchPolicy` class is exposed to end users
+        # of RLlib and will remain (relatively) stable across RLlib
+        # releases.
+        from ray.rllib.policy import Policy
+        @DeveloperAPI
+        class TorchPolicy(Policy):
+            ...
+    """
+
+    _mark_annotated(obj)
+    return obj
+
+
+def ExperimentalAPI(obj):
+    """Decorator for documenting experimental APIs.
+
+    Experimental APIs are classes and methods that are in development and may
+    change at any time in their development process. You should not expect
+    these APIs to be stable until their tag is changed to `DeveloperAPI` or
+    `PublicAPI`.
+
+    Subclasses that inherit from a ``@ExperimentalAPI`` base class can be
+    assumed experimental as well.
+
+    .. testcode::
+        :skipif: True
+
+        from ray.rllib.policy import Policy
+        class TorchPolicy(Policy):
+            ...
+            # Indicates that the `TorchPolicy.loss` method is a new and
+            # experimental API and may change frequently in future
+            # releases.
+            @ExperimentalAPI
+            def loss(self, model, action_dist, train_batch):
+                ...
+    """
+
+    _mark_annotated(obj)
+    return obj
+
+
+def OldAPIStack(obj):
+    """Decorator for classes/methods/functions belonging to the old API stack.
+
+    These should be deprecated at some point after Ray 3.0 (RLlib GA).
+    It is recommended for users to start exploring (and coding against) the new API
+    stack instead.
+    """
+    # No effect yet.
+
+    _mark_annotated(obj)
+    return obj
+
+
+def OverrideToImplementCustomLogic(obj):
+    """Users should override this in their sub-classes to implement custom logic.
+
+    Used in Algorithm and Policy to tag methods that need overriding, e.g.
+    `Policy.loss()`.
+
+    .. testcode::
+        :skipif: True
+
+        from ray.rllib.policy.torch_policy import TorchPolicy
+        @overrides(TorchPolicy)
+        @OverrideToImplementCustomLogic
+        def loss(self, ...):
+            # implement custom loss function here ...
+            # ... w/o calling the corresponding `super().loss()` method.
+            ...
+
+    """
+    obj.__is_overridden__ = False
+    return obj
+
+
+def OverrideToImplementCustomLogic_CallToSuperRecommended(obj):
+    """Users should override this in their sub-classes to implement custom logic.
+
+    Thereby, it is recommended (but not required) to call the super-class'
+    corresponding method.
+
+    Used in Algorithm and Policy to tag methods that need overriding, but the
+    super class' method should still be called, e.g.
+    `Algorithm.setup()`.
+
+    .. testcode::
+        :skipif: True
+
+        from ray import tune
+        @overrides(tune.Trainable)
+        @OverrideToImplementCustomLogic_CallToSuperRecommended
+        def setup(self, config):
+            # implement custom setup logic here ...
+            super().setup(config)
+            # ... or here (after having called super()'s setup method.
+    """
+    obj.__is_overridden__ = False
+    return obj
+
+
+def is_overridden(obj):
+    """Check whether a function has been overridden.
+
+    Note, this only works for API calls decorated with OverrideToImplementCustomLogic
+    or OverrideToImplementCustomLogic_CallToSuperRecommended.
+    """
+    return getattr(obj, "__is_overridden__", True)
+
+
+# Backward compatibility.
+Deprecated = Deprecated

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/filter.py

@@ -0,0 +1,420 @@
+import logging
+import threading
+
+import numpy as np
+import tree  # pip install dm_tree
+
+from ray.rllib.utils.annotations import OldAPIStack
+from ray.rllib.utils.deprecation import Deprecated
+from ray.rllib.utils.numpy import SMALL_NUMBER
+from ray.rllib.utils.typing import TensorStructType
+from ray.rllib.utils.serialization import _serialize_ndarray, _deserialize_ndarray
+from ray.rllib.utils.deprecation import deprecation_warning
+
+logger = logging.getLogger(__name__)
+
+
+@OldAPIStack
+class Filter:
+    """Processes input, possibly statefully."""
+
+    def apply_changes(self, other: "Filter", *args, **kwargs) -> None:
+        """Updates self with "new state" from other filter."""
+        raise NotImplementedError
+
+    def copy(self) -> "Filter":
+        """Creates a new object with same state as self.
+
+        Returns:
+            A copy of self.
+        """
+        raise NotImplementedError
+
+    def sync(self, other: "Filter") -> None:
+        """Copies all state from other filter to self."""
+        raise NotImplementedError
+
+    def reset_buffer(self) -> None:
+        """Creates copy of current state and resets accumulated state"""
+        raise NotImplementedError
+
+    def as_serializable(self) -> "Filter":
+        raise NotImplementedError
+
+    @Deprecated(new="Filter.reset_buffer()", error=True)
+    def clear_buffer(self):
+        pass
+
+
+@OldAPIStack
+class NoFilter(Filter):
+    is_concurrent = True
+
+    def __call__(self, x: TensorStructType, update=True):
+        # Process no further if already np.ndarray, dict, or tuple.
+        if isinstance(x, (np.ndarray, dict, tuple)):
+            return x
+
+        try:
+            return np.asarray(x)
+        except Exception:
+            raise ValueError("Failed to convert to array", x)
+
+    def apply_changes(self, other: "NoFilter", *args, **kwargs) -> None:
+        pass
+
+    def copy(self) -> "NoFilter":
+        return self
+
+    def sync(self, other: "NoFilter") -> None:
+        pass
+
+    def reset_buffer(self) -> None:
+        pass
+
+    def as_serializable(self) -> "NoFilter":
+        return self
+
+
+# http://www.johndcook.com/blog/standard_deviation/
+@OldAPIStack
+class RunningStat:
+    def __init__(self, shape=()):
+        self.num_pushes = 0
+        self.mean_array = np.zeros(shape)
+        self.std_array = np.zeros(shape)
+
+    def copy(self):
+        other = RunningStat()
+        # TODO: Remove these safe-guards if not needed anymore.
+        other.num_pushes = self.num_pushes if hasattr(self, "num_pushes") else self._n
+        other.mean_array = (
+            np.copy(self.mean_array)
+            if hasattr(self, "mean_array")
+            else np.copy(self._M)
+        )
+        other.std_array = (
+            np.copy(self.std_array) if hasattr(self, "std_array") else np.copy(self._S)
+        )
+        return other
+
+    def push(self, x):
+        x = np.asarray(x)
+        # Unvectorized update of the running statistics.
+        if x.shape != self.mean_array.shape:
+            raise ValueError(
+                "Unexpected input shape {}, expected {}, value = {}".format(
+                    x.shape, self.mean_array.shape, x
+                )
+            )
+        self.num_pushes += 1
+        if self.num_pushes == 1:
+            self.mean_array[...] = x
+        else:
+            delta = x - self.mean_array
+            self.mean_array[...] += delta / self.num_pushes
+            self.std_array[...] += (
+                (delta / self.num_pushes) * delta * (self.num_pushes - 1)
+            )
+
+    def update(self, other):
+        n1 = float(self.num_pushes)
+        n2 = float(other.num_pushes)
+        n = n1 + n2
+        if n == 0:
+            # Avoid divide by zero, which creates nans
+            return
+        delta = self.mean_array - other.mean_array
+        delta2 = delta * delta
+        m = (n1 * self.mean_array + n2 * other.mean_array) / n
+        s = self.std_array + other.std_array + (delta2 / n) * n1 * n2
+        self.num_pushes = n
+        self.mean_array = m
+        self.std_array = s
+
+    def __repr__(self):
+        return "(n={}, mean_mean={}, mean_std={})".format(
+            self.n, np.mean(self.mean), np.mean(self.std)
+        )
+
+    @property
+    def n(self):
+        return self.num_pushes
+
+    @property
+    def mean(self):
+        return self.mean_array
+
+    @property
+    def var(self):
+        return (
+            self.std_array / (self.num_pushes - 1)
+            if self.num_pushes > 1
+            else np.square(self.mean_array)
+        ).astype(np.float32)
+
+    @property
+    def std(self):
+        return np.sqrt(self.var)
+
+    @property
+    def shape(self):
+        return self.mean_array.shape
+
+    def to_state(self):
+        return {
+            "num_pushes": self.num_pushes,
+            "mean_array": _serialize_ndarray(self.mean_array),
+            "std_array": _serialize_ndarray(self.std_array),
+        }
+
+    @staticmethod
+    def from_state(state):
+        running_stats = RunningStat()
+        running_stats.num_pushes = state["num_pushes"]
+        running_stats.mean_array = _deserialize_ndarray(state["mean_array"])
+        running_stats.std_array = _deserialize_ndarray(state["std_array"])
+        return running_stats
+
+
+@OldAPIStack
+class MeanStdFilter(Filter):
+    """Keeps track of a running mean for seen states"""
+
+    is_concurrent = False
+
+    def __init__(self, shape, demean=True, destd=True, clip=10.0):
+        self.shape = shape
+        # We don't have a preprocessor, if shape is None (Discrete) or
+        # flat_shape is Tuple[np.ndarray] or Dict[str, np.ndarray]
+        # (complex inputs).
+        flat_shape = tree.flatten(self.shape)
+        self.no_preprocessor = shape is None or (
+            isinstance(self.shape, (dict, tuple))
+            and len(flat_shape) > 0
+            and isinstance(flat_shape[0], np.ndarray)
+        )
+        # If preprocessing (flattening dicts/tuples), make sure shape
+        # is an np.ndarray, so we don't confuse it with a complex Tuple
+        # space's shape structure (which is a Tuple[np.ndarray]).
+        if not self.no_preprocessor:
+            self.shape = np.array(self.shape)
+        self.demean = demean
+        self.destd = destd
+        self.clip = clip
+        # Running stats.
+        self.running_stats = tree.map_structure(lambda s: RunningStat(s), self.shape)
+
+        # In distributed rollouts, each worker sees different states.
+        # The buffer is used to keep track of deltas amongst all the
+        # observation filters.
+        self.buffer = None
+        self.reset_buffer()
+
+    def reset_buffer(self) -> None:
+        self.buffer = tree.map_structure(lambda s: RunningStat(s), self.shape)
+
+    def apply_changes(
+        self, other: "MeanStdFilter", with_buffer: bool = False, *args, **kwargs
+    ) -> None:
+        """Applies updates from the buffer of another filter.
+
+        Args:
+            other: Other filter to apply info from
+            with_buffer: Flag for specifying if the buffer should be
+                copied from other.
+
+        .. testcode::
+            :skipif: True
+
+            a = MeanStdFilter(())
+            a(1)
+            a(2)
+            print([a.running_stats.n, a.running_stats.mean, a.buffer.n])
+
+        .. testoutput::
+
+            [2, 1.5, 2]
+
+        .. testcode::
+            :skipif: True
+
+            b = MeanStdFilter(())
+            b(10)
+            a.apply_changes(b, with_buffer=False)
+            print([a.running_stats.n, a.running_stats.mean, a.buffer.n])
+
+        .. testoutput::
+
+            [3, 4.333333333333333, 2]
+
+        .. testcode::
+            :skipif: True
+
+            a.apply_changes(b, with_buffer=True)
+            print([a.running_stats.n, a.running_stats.mean, a.buffer.n])
+
+        .. testoutput::
+
+            [4, 5.75, 1]
+        """
+        tree.map_structure(
+            lambda rs, other_rs: rs.update(other_rs), self.running_stats, other.buffer
+        )
+        if with_buffer:
+            self.buffer = tree.map_structure(lambda b: b.copy(), other.buffer)
+
+    def copy(self) -> "MeanStdFilter":
+        """Returns a copy of `self`."""
+        other = MeanStdFilter(self.shape)
+        other.sync(self)
+        return other
+
+    def as_serializable(self) -> "MeanStdFilter":
+        return self.copy()
+
+    def sync(self, other: "MeanStdFilter") -> None:
+        """Syncs all fields together from other filter.
+
+        .. testcode::
+            :skipif: True
+
+            a = MeanStdFilter(())
+            a(1)
+            a(2)
+            print([a.running_stats.n, a.running_stats.mean, a.buffer.n])
+
+        .. testoutput::
+
+            [2, array(1.5), 2]
+
+        .. testcode::
+            :skipif: True
+
+            b = MeanStdFilter(())
+            b(10)
+            print([b.running_stats.n, b.running_stats.mean, b.buffer.n])
+
+        .. testoutput::
+
+            [1, array(10.0), 1]
+
+        .. testcode::
+            :skipif: True
+
+            a.sync(b)
+            print([a.running_stats.n, a.running_stats.mean, a.buffer.n])
+
+        .. testoutput::
+
+            [1, array(10.0), 1]
+        """
+        self.demean = other.demean
+        self.destd = other.destd
+        self.clip = other.clip
+        self.running_stats = tree.map_structure(
+            lambda rs: rs.copy(), other.running_stats
+        )
+        self.buffer = tree.map_structure(lambda b: b.copy(), other.buffer)
+
+    def __call__(self, x: TensorStructType, update: bool = True) -> TensorStructType:
+        if self.no_preprocessor:
+            x = tree.map_structure(lambda x_: np.asarray(x_), x)
+        else:
+            x = np.asarray(x)
+
+        def _helper(x, rs, buffer, shape):
+            # Discrete|MultiDiscrete spaces -> No normalization.
+            if shape is None:
+                return x
+
+            # Keep dtype as is througout this filter.
+            orig_dtype = x.dtype
+
+            if update:
+                if len(x.shape) == len(rs.shape) + 1:
+                    # The vectorized case.
+                    for i in range(x.shape[0]):
+                        rs.push(x[i])
+                        buffer.push(x[i])
+                else:
+                    # The unvectorized case.
+                    rs.push(x)
+                    buffer.push(x)
+            if self.demean:
+                x = x - rs.mean
+            if self.destd:
+                x = x / (rs.std + SMALL_NUMBER)
+            if self.clip:
+                x = np.clip(x, -self.clip, self.clip)
+            return x.astype(orig_dtype)
+
+        if self.no_preprocessor:
+            return tree.map_structure_up_to(
+                x, _helper, x, self.running_stats, self.buffer, self.shape
+            )
+        else:
+            return _helper(x, self.running_stats, self.buffer, self.shape)
+
+
+@OldAPIStack
+class ConcurrentMeanStdFilter(MeanStdFilter):
+    is_concurrent = True
+
+    def __init__(self, *args, **kwargs):
+        super(ConcurrentMeanStdFilter, self).__init__(*args, **kwargs)
+        deprecation_warning(
+            old="ConcurrentMeanStdFilter",
+            error=False,
+            help="ConcurrentMeanStd filters are only used for testing and will "
+            "therefore be deprecated in the course of moving to the "
+            "Connetors API, where testing of filters will be done by other "
+            "means.",
+        )
+
+        self._lock = threading.RLock()
+
+        def lock_wrap(func):
+            def wrapper(*args, **kwargs):
+                with self._lock:
+                    return func(*args, **kwargs)
+
+            return wrapper
+
+        self.__getattribute__ = lock_wrap(self.__getattribute__)
+
+    def as_serializable(self) -> "MeanStdFilter":
+        """Returns non-concurrent version of current class"""
+        other = MeanStdFilter(self.shape)
+        other.sync(self)
+        return other
+
+    def copy(self) -> "ConcurrentMeanStdFilter":
+        """Returns a copy of Filter."""
+        other = ConcurrentMeanStdFilter(self.shape)
+        other.sync(self)
+        return other
+
+    def __repr__(self) -> str:
+        return "ConcurrentMeanStdFilter({}, {}, {}, {}, {}, {})".format(
+            self.shape,
+            self.demean,
+            self.destd,
+            self.clip,
+            self.running_stats,
+            self.buffer,
+        )
+
+
+@OldAPIStack
+def get_filter(filter_config, shape):
+    if filter_config == "MeanStdFilter":
+        return MeanStdFilter(shape, clip=None)
+    elif filter_config == "ConcurrentMeanStdFilter":
+        return ConcurrentMeanStdFilter(shape, clip=None)
+    elif filter_config == "NoFilter":
+        return NoFilter()
+    elif callable(filter_config):
+        return filter_config(shape)
+    else:
+        raise Exception("Unknown observation_filter: " + str(filter_config))

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/framework.py

@@ -0,0 +1,352 @@
+import logging
+import numpy as np
+import os
+import sys
+from typing import Any, Optional
+
+import tree  # pip install dm_tree
+
+from ray.rllib.utils.annotations import DeveloperAPI, PublicAPI
+from ray.rllib.utils.deprecation import Deprecated
+from ray.rllib.utils.typing import (
+    TensorShape,
+    TensorStructType,
+    TensorType,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@PublicAPI
+def convert_to_tensor(
+    data: TensorStructType,
+    framework: str,
+    device: Optional[str] = None,
+):
+    """Converts any nested numpy struct into framework-specific tensors.
+
+    Args:
+        data: The input data (numpy) to convert to framework-specific tensors.
+        framework: The framework to convert to. Only "torch" and "tf2" allowed.
+        device: An optional device name (for torch only).
+
+    Returns:
+        The converted tensor struct matching the input data.
+    """
+    if framework == "torch":
+        from ray.rllib.utils.torch_utils import convert_to_torch_tensor
+
+        return convert_to_torch_tensor(data, device=device)
+    elif framework == "tf2":
+        _, tf, _ = try_import_tf()
+
+        return tree.map_structure(lambda s: tf.convert_to_tensor(s), data)
+    raise NotImplementedError(
+        f"framework={framework} not supported in `convert_to_tensor()`!"
+    )
+
+
+@PublicAPI
+def try_import_jax(error: bool = False):
+    """Tries importing JAX and FLAX and returns both modules (or Nones).
+
+    Args:
+        error: Whether to raise an error if JAX/FLAX cannot be imported.
+
+    Returns:
+        Tuple containing the jax- and the flax modules.
+
+    Raises:
+        ImportError: If error=True and JAX is not installed.
+    """
+    if "RLLIB_TEST_NO_JAX_IMPORT" in os.environ:
+        logger.warning("Not importing JAX for test purposes.")
+        return None, None
+
+    try:
+        import jax
+        import flax
+    except ImportError:
+        if error:
+            raise ImportError(
+                "Could not import JAX! RLlib requires you to "
+                "install at least one deep-learning framework: "
+                "`pip install [torch|tensorflow|jax]`."
+            )
+        return None, None
+
+    return jax, flax
+
+
+@PublicAPI
+def try_import_tf(error: bool = False):
+    """Tries importing tf and returns the module (or None).
+
+    Args:
+        error: Whether to raise an error if tf cannot be imported.
+
+    Returns:
+        Tuple containing
+        1) tf1.x module (either from tf2.x.compat.v1 OR as tf1.x).
+        2) tf module (resulting from `import tensorflow`). Either tf1.x or
+        2.x. 3) The actually installed tf version as int: 1 or 2.
+
+    Raises:
+        ImportError: If error=True and tf is not installed.
+    """
+    tf_stub = _TFStub()
+    # Make sure, these are reset after each test case
+    # that uses them: del os.environ["RLLIB_TEST_NO_TF_IMPORT"]
+    if "RLLIB_TEST_NO_TF_IMPORT" in os.environ:
+        logger.warning("Not importing TensorFlow for test purposes")
+        return None, tf_stub, None
+
+    if "TF_CPP_MIN_LOG_LEVEL" not in os.environ:
+        os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+
+    # Try to reuse already imported tf module. This will avoid going through
+    # the initial import steps below and thereby switching off v2_behavior
+    # (switching off v2 behavior twice breaks all-framework tests for eager).
+    was_imported = False
+    if "tensorflow" in sys.modules:
+        tf_module = sys.modules["tensorflow"]
+        was_imported = True
+
+    else:
+        try:
+            import tensorflow as tf_module
+        except ImportError:
+            if error:
+                raise ImportError(
+                    "Could not import TensorFlow! RLlib requires you to "
+                    "install at least one deep-learning framework: "
+                    "`pip install [torch|tensorflow|jax]`."
+                )
+            return None, tf_stub, None
+
+    # Try "reducing" tf to tf.compat.v1.
+    try:
+        tf1_module = tf_module.compat.v1
+        tf1_module.logging.set_verbosity(tf1_module.logging.ERROR)
+        if not was_imported:
+            tf1_module.disable_v2_behavior()
+            tf1_module.enable_resource_variables()
+        tf1_module.logging.set_verbosity(tf1_module.logging.WARN)
+    # No compat.v1 -> return tf as is.
+    except AttributeError:
+        tf1_module = tf_module
+
+    if not hasattr(tf_module, "__version__"):
+        version = 1  # sphinx doc gen
+    else:
+        version = 2 if "2." in tf_module.__version__[:2] else 1
+
+    return tf1_module, tf_module, version
+
+
+# Fake module for tf.
+class _TFStub:
+    def __init__(self) -> None:
+        self.keras = _KerasStub()
+
+    def __bool__(self):
+        # if tf should return False
+        return False
+
+
+# Fake module for tf.keras.
+class _KerasStub:
+    def __init__(self) -> None:
+        self.Model = _FakeTfClassStub
+
+
+# Fake classes under keras (e.g for tf.keras.Model)
+class _FakeTfClassStub:
+    def __init__(self, *a, **kw):
+        raise ImportError("Could not import `tensorflow`. Try pip install tensorflow.")
+
+
+@DeveloperAPI
+def tf_function(tf_module):
+    """Conditional decorator for @tf.function.
+
+    Use @tf_function(tf) instead to avoid errors if tf is not installed."""
+
+    # The actual decorator to use (pass in `tf` (which could be None)).
+    def decorator(func):
+        # If tf not installed -> return function as is (won't be used anyways).
+        if tf_module is None or tf_module.executing_eagerly():
+            return func
+        # If tf installed, return @tf.function-decorated function.
+        return tf_module.function(func)
+
+    return decorator
+
+
+@PublicAPI
+def try_import_tfp(error: bool = False):
+    """Tries importing tfp and returns the module (or None).
+
+    Args:
+        error: Whether to raise an error if tfp cannot be imported.
+
+    Returns:
+        The tfp module.
+
+    Raises:
+        ImportError: If error=True and tfp is not installed.
+    """
+    if "RLLIB_TEST_NO_TF_IMPORT" in os.environ:
+        logger.warning("Not importing TensorFlow Probability for test purposes.")
+        return None
+
+    try:
+        import tensorflow_probability as tfp
+
+        return tfp
+    except ImportError as e:
+        if error:
+            raise e
+        return None
+
+
+# Fake module for torch.nn.
+class _NNStub:
+    def __init__(self, *a, **kw):
+        # Fake nn.functional module within torch.nn.
+        self.functional = None
+        self.Module = _FakeTorchClassStub
+        self.parallel = _ParallelStub()
+
+
+# Fake class for e.g. torch.nn.Module to allow it to be inherited from.
+class _FakeTorchClassStub:
+    def __init__(self, *a, **kw):
+        raise ImportError("Could not import `torch`. Try pip install torch.")
+
+
+class _ParallelStub:
+    def __init__(self, *a, **kw):
+        self.DataParallel = _FakeTorchClassStub
+        self.DistributedDataParallel = _FakeTorchClassStub
+
+
+@PublicAPI
+def try_import_torch(error: bool = False):
+    """Tries importing torch and returns the module (or None).
+
+    Args:
+        error: Whether to raise an error if torch cannot be imported.
+
+    Returns:
+        Tuple consisting of the torch- AND torch.nn modules.
+
+    Raises:
+        ImportError: If error=True and PyTorch is not installed.
+    """
+    if "RLLIB_TEST_NO_TORCH_IMPORT" in os.environ:
+        logger.warning("Not importing PyTorch for test purposes.")
+        return _torch_stubs()
+
+    try:
+        import torch
+        import torch.nn as nn
+
+        return torch, nn
+    except ImportError:
+        if error:
+            raise ImportError(
+                "Could not import PyTorch! RLlib requires you to "
+                "install at least one deep-learning framework: "
+                "`pip install [torch|tensorflow|jax]`."
+            )
+        return _torch_stubs()
+
+
+def _torch_stubs():
+    nn = _NNStub()
+    return None, nn
+
+
+@DeveloperAPI
+def get_variable(
+    value: Any,
+    framework: str = "tf",
+    trainable: bool = False,
+    tf_name: str = "unnamed-variable",
+    torch_tensor: bool = False,
+    device: Optional[str] = None,
+    shape: Optional[TensorShape] = None,
+    dtype: Optional[TensorType] = None,
+) -> Any:
+    """Creates a tf variable, a torch tensor, or a python primitive.
+
+    Args:
+        value: The initial value to use. In the non-tf case, this will
+            be returned as is. In the tf case, this could be a tf-Initializer
+            object.
+        framework: One of "tf", "torch", or None.
+        trainable: Whether the generated variable should be
+            trainable (tf)/require_grad (torch) or not (default: False).
+        tf_name: For framework="tf": An optional name for the
+            tf.Variable.
+        torch_tensor: For framework="torch": Whether to actually create
+            a torch.tensor, or just a python value (default).
+        device: An optional torch device to use for
+            the created torch tensor.
+        shape: An optional shape to use iff `value`
+            does not have any (e.g. if it's an initializer w/o explicit value).
+        dtype: An optional dtype to use iff `value` does
+            not have any (e.g. if it's an initializer w/o explicit value).
+            This should always be a numpy dtype (e.g. np.float32, np.int64).
+
+    Returns:
+        A framework-specific variable (tf.Variable, torch.tensor, or
+        python primitive).
+    """
+    if framework in ["tf2", "tf"]:
+        import tensorflow as tf
+
+        dtype = dtype or getattr(
+            value,
+            "dtype",
+            tf.float32
+            if isinstance(value, float)
+            else tf.int32
+            if isinstance(value, int)
+            else None,
+        )
+        return tf.compat.v1.get_variable(
+            tf_name,
+            initializer=value,
+            dtype=dtype,
+            trainable=trainable,
+            **({} if shape is None else {"shape": shape}),
+        )
+    elif framework == "torch" and torch_tensor is True:
+        torch, _ = try_import_torch()
+        if not isinstance(value, np.ndarray):
+            value = np.array(value)
+        var_ = torch.from_numpy(value)
+        if dtype in [torch.float32, np.float32]:
+            var_ = var_.float()
+        elif dtype in [torch.int32, np.int32]:
+            var_ = var_.int()
+        elif dtype in [torch.float64, np.float64]:
+            var_ = var_.double()
+
+        if device:
+            var_ = var_.to(device)
+        var_.requires_grad = trainable
+        return var_
+    # torch or None: Return python primitive.
+    return value
+
+
+@Deprecated(
+    old="rllib/utils/framework.py::get_activation_fn",
+    new="rllib/models/utils.py::get_activation_fn",
+    error=True,
+)
+def get_activation_fn(name: Optional[str] = None, framework: str = "tf"):
+    pass

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/minibatch_utils.py

@@ -0,0 +1,337 @@
+import math
+from typing import List, Optional
+
+from ray.rllib.policy.sample_batch import MultiAgentBatch, concat_samples
+from ray.rllib.policy.sample_batch import SampleBatch
+from ray.rllib.utils.annotations import DeveloperAPI
+from ray.rllib.utils.typing import EpisodeType
+
+
+@DeveloperAPI
+class MiniBatchIteratorBase:
+    """The base class for all minibatch iterators."""
+
+    def __init__(
+        self,
+        batch: MultiAgentBatch,
+        *,
+        num_epochs: int = 1,
+        shuffle_batch_per_epoch: bool = True,
+        minibatch_size: int,
+        num_total_minibatches: int = 0,
+    ) -> None:
+        """Initializes a MiniBatchIteratorBase instance.
+
+        Args:
+            batch: The input multi-agent batch.
+            num_epochs: The number of complete passes over the entire train batch. Each
+                pass might be further split into n minibatches (if `minibatch_size`
+                provided). The train batch is generated from the given `episodes`
+                through the Learner connector pipeline.
+            minibatch_size: The size of minibatches to use to further split the train
+                batch into per epoch. The train batch is generated from the given
+                `episodes` through the Learner connector pipeline.
+            num_total_minibatches: The total number of minibatches to loop through
+                (over all `num_epochs` epochs). It's only required to set this to != 0
+                in multi-agent + multi-GPU situations, in which the MultiAgentEpisodes
+                themselves are roughly sharded equally, however, they might contain
+                SingleAgentEpisodes with very lopsided length distributions. Thus,
+                without this fixed, pre-computed value, one Learner might go through a
+                different number of minibatche passes than others causing a deadlock.
+        """
+        pass
+
+
+@DeveloperAPI
+class MiniBatchCyclicIterator(MiniBatchIteratorBase):
+    """This implements a simple multi-agent minibatch iterator.
+
+    This iterator will split the input multi-agent batch into minibatches where the
+    size of batch for each module_id (aka policy_id) is equal to minibatch_size. If the
+    input batch is smaller than minibatch_size, then the iterator will cycle through
+    the batch until it has covered `num_epochs` epochs.
+    """
+
+    def __init__(
+        self,
+        batch: MultiAgentBatch,
+        *,
+        num_epochs: int = 1,
+        minibatch_size: int,
+        shuffle_batch_per_epoch: bool = True,
+        num_total_minibatches: int = 0,
+        _uses_new_env_runners: bool = False,
+    ) -> None:
+        """Initializes a MiniBatchCyclicIterator instance."""
+        super().__init__(
+            batch,
+            num_epochs=num_epochs,
+            minibatch_size=minibatch_size,
+            shuffle_batch_per_epoch=shuffle_batch_per_epoch,
+        )
+
+        self._batch = batch
+        self._minibatch_size = minibatch_size
+        self._num_epochs = num_epochs
+        self._shuffle_batch_per_epoch = shuffle_batch_per_epoch
+
+        # mapping from module_id to the start index of the batch
+        self._start = {mid: 0 for mid in batch.policy_batches.keys()}
+        # mapping from module_id to the number of epochs covered for each module_id
+        self._num_covered_epochs = {mid: 0 for mid in batch.policy_batches.keys()}
+
+        self._uses_new_env_runners = _uses_new_env_runners
+
+        self._minibatch_count = 0
+        self._num_total_minibatches = num_total_minibatches
+
+    def __iter__(self):
+        while (
+            # Make sure each item in the total batch gets at least iterated over
+            # `self._num_epochs` times.
+            (
+                self._num_total_minibatches == 0
+                and min(self._num_covered_epochs.values()) < self._num_epochs
+            )
+            # Make sure we reach at least the given minimum number of mini-batches.
+            or (
+                self._num_total_minibatches > 0
+                and self._minibatch_count < self._num_total_minibatches
+            )
+        ):
+            minibatch = {}
+            for module_id, module_batch in self._batch.policy_batches.items():
+
+                if len(module_batch) == 0:
+                    raise ValueError(
+                        f"The batch for module_id {module_id} is empty! "
+                        "This will create an infinite loop because we need to cover "
+                        "the same number of samples for each module_id."
+                    )
+                s = self._start[module_id]  # start
+
+                # TODO (sven): Fix this bug for LSTMs:
+                #  In an RNN-setting, the Learner connector already has zero-padded
+                #  and added a timerank to the batch. Thus, n_step would still be based
+                #  on the BxT dimension, rather than the new B dimension (excluding T),
+                #  which then leads to minibatches way too large.
+                #  However, changing this already would break APPO/IMPALA w/o LSTMs as
+                #  these setups require sequencing, BUT their batches are not yet time-
+                #  ranked (this is done only in their loss functions via the
+                #  `make_time_major` utility).
+                #  Get rid of the _uses_new_env_runners c'tor arg, once this work is
+                #  done.
+                n_steps = self._minibatch_size
+
+                samples_to_concat = []
+
+                # get_len is a function that returns the length of a batch
+                # if we are not slicing the batch in the batch dimension B, then
+                # the length of the batch is simply the length of the batch
+                # o.w the length of the batch is the length list of seq_lens.
+                if module_batch._slice_seq_lens_in_B:
+                    assert module_batch.get(SampleBatch.SEQ_LENS) is not None, (
+                        "MiniBatchCyclicIterator requires SampleBatch.SEQ_LENS"
+                        "to be present in the batch for slicing a batch in the batch "
+                        "dimension B."
+                    )
+
+                    def get_len(b):
+                        return len(b[SampleBatch.SEQ_LENS])
+
+                    if self._uses_new_env_runners:
+                        n_steps = int(
+                            get_len(module_batch)
+                            * (self._minibatch_size / len(module_batch))
+                        )
+
+                else:
+
+                    def get_len(b):
+                        return len(b)
+
+                # Cycle through the batch until we have enough samples.
+                while s + n_steps >= get_len(module_batch):
+                    sample = module_batch[s:]
+                    samples_to_concat.append(sample)
+                    len_sample = get_len(sample)
+                    assert len_sample > 0, "Length of a sample must be > 0!"
+                    n_steps -= len_sample
+                    s = 0
+                    self._num_covered_epochs[module_id] += 1
+                    # Shuffle the individual single-agent batch, if required.
+                    # This should happen once per minibatch iteration in order to make
+                    # each iteration go through a different set of minibatches.
+                    if self._shuffle_batch_per_epoch:
+                        module_batch.shuffle()
+
+                e = s + n_steps  # end
+                if e > s:
+                    samples_to_concat.append(module_batch[s:e])
+
+                # concatenate all the samples, we should have minibatch_size of sample
+                # after this step
+                minibatch[module_id] = concat_samples(samples_to_concat)
+                # roll minibatch to zero when we reach the end of the batch
+                self._start[module_id] = e
+
+            # Note (Kourosh): env_steps is the total number of env_steps that this
+            # multi-agent batch is covering. It should be simply inherited from the
+            # original multi-agent batch.
+            minibatch = MultiAgentBatch(minibatch, len(self._batch))
+            yield minibatch
+
+            self._minibatch_count += 1
+
+
+class MiniBatchDummyIterator(MiniBatchIteratorBase):
+    def __init__(self, batch: MultiAgentBatch, **kwargs):
+        super().__init__(batch, **kwargs)
+        self._batch = batch
+
+    def __iter__(self):
+        yield self._batch
+
+
+@DeveloperAPI
+class ShardBatchIterator:
+    """Iterator for sharding batch into num_shards batches.
+
+    Args:
+        batch: The input multi-agent batch.
+        num_shards: The number of shards to split the batch into.
+
+    Yields:
+        A MultiAgentBatch of size len(batch) / num_shards.
+    """
+
+    def __init__(self, batch: MultiAgentBatch, num_shards: int):
+        self._batch = batch
+        self._num_shards = num_shards
+
+    def __iter__(self):
+        for i in range(self._num_shards):
+            # TODO (sven): The following way of sharding a multi-agent batch destroys
+            #  the relationship of the different agents' timesteps to each other.
+            #  Thus, in case the algorithm requires agent-synchronized data (aka.
+            #  "lockstep"), the `ShardBatchIterator` cannot be used.
+            batch_to_send = {}
+            for pid, sub_batch in self._batch.policy_batches.items():
+                batch_size = math.ceil(len(sub_batch) / self._num_shards)
+                start = batch_size * i
+                end = min(start + batch_size, len(sub_batch))
+                batch_to_send[pid] = sub_batch[int(start) : int(end)]
+            # TODO (Avnish): int(batch_size) ? How should we shard MA batches really?
+            new_batch = MultiAgentBatch(batch_to_send, int(batch_size))
+            yield new_batch
+
+
+@DeveloperAPI
+class ShardEpisodesIterator:
+    """Iterator for sharding a list of Episodes into `num_shards` lists of Episodes."""
+
+    def __init__(
+        self,
+        episodes: List[EpisodeType],
+        num_shards: int,
+        len_lookback_buffer: Optional[int] = None,
+    ):
+        """Initializes a ShardEpisodesIterator instance.
+
+        Args:
+            episodes: The input list of Episodes.
+            num_shards: The number of shards to split the episodes into.
+            len_lookback_buffer: An optional length of a lookback buffer to enforce
+                on the returned shards. When spitting an episode, the second piece
+                might need a lookback buffer (into the first piece) depending on the
+                user's settings.
+        """
+        self._episodes = sorted(episodes, key=len, reverse=True)
+        self._num_shards = num_shards
+        self._len_lookback_buffer = len_lookback_buffer
+        self._total_length = sum(len(e) for e in episodes)
+        self._target_lengths = [0 for _ in range(self._num_shards)]
+        remaining_length = self._total_length
+        for s in range(self._num_shards):
+            len_ = remaining_length // (num_shards - s)
+            self._target_lengths[s] = len_
+            remaining_length -= len_
+
+    def __iter__(self) -> List[EpisodeType]:
+        """Runs one iteration through this sharder.
+
+        Yields:
+            A sub-list of Episodes of size roughly `len(episodes) / num_shards`. The
+            yielded sublists might have slightly different total sums of episode
+            lengths, in order to not have to drop even a single timestep.
+        """
+        sublists = [[] for _ in range(self._num_shards)]
+        lengths = [0 for _ in range(self._num_shards)]
+        episode_index = 0
+
+        while episode_index < len(self._episodes):
+            episode = self._episodes[episode_index]
+            min_index = lengths.index(min(lengths))
+
+            # Add the whole episode if it fits within the target length
+            if lengths[min_index] + len(episode) <= self._target_lengths[min_index]:
+                sublists[min_index].append(episode)
+                lengths[min_index] += len(episode)
+                episode_index += 1
+            # Otherwise, slice the episode
+            else:
+                remaining_length = self._target_lengths[min_index] - lengths[min_index]
+                if remaining_length > 0:
+                    slice_part, remaining_part = (
+                        # Note that the first slice will automatically "inherit" the
+                        # lookback buffer size of the episode.
+                        episode[:remaining_length],
+                        # However, the second slice might need a user defined lookback
+                        # buffer (into the first slice).
+                        episode.slice(
+                            slice(remaining_length, None),
+                            len_lookback_buffer=self._len_lookback_buffer,
+                        ),
+                    )
+                    sublists[min_index].append(slice_part)
+                    lengths[min_index] += len(slice_part)
+                    self._episodes[episode_index] = remaining_part
+                else:
+                    assert remaining_length == 0
+                    sublists[min_index].append(episode)
+                    episode_index += 1
+
+        for sublist in sublists:
+            yield sublist
+
+
+@DeveloperAPI
+class ShardObjectRefIterator:
+    """Iterator for sharding a list of ray ObjectRefs into num_shards sub-lists.
+
+    Args:
+        object_refs: The input list of ray ObjectRefs.
+        num_shards: The number of shards to split the references into.
+
+    Yields:
+        A sub-list of ray ObjectRefs with lengths as equal as possible.
+    """
+
+    def __init__(self, object_refs, num_shards: int):
+        self._object_refs = object_refs
+        self._num_shards = num_shards
+
+    def __iter__(self):
+        # Calculate the size of each sublist
+        n = len(self._object_refs)
+        sublist_size = n // self._num_shards
+        remaining_elements = n % self._num_shards
+
+        start = 0
+        for i in range(self._num_shards):
+            # Determine the end index for the current sublist
+            end = start + sublist_size + (1 if i < remaining_elements else 0)
+            # Append the sublist to the result
+            yield self._object_refs[start:end]
+            # Update the start index for the next sublist
+            start = end

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/policy.py

@@ -0,0 +1,303 @@
+import gymnasium as gym
+import logging
+import numpy as np
+from typing import (
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+    TYPE_CHECKING,
+)
+import tree  # pip install dm_tree
+
+
+import ray.cloudpickle as pickle
+from ray.rllib.core.rl_module import validate_module_id
+from ray.rllib.models.preprocessors import ATARI_OBS_SHAPE
+from ray.rllib.policy.policy import PolicySpec
+from ray.rllib.policy.sample_batch import SampleBatch
+from ray.rllib.utils.deprecation import Deprecated
+from ray.rllib.utils.framework import try_import_tf
+from ray.rllib.utils.typing import (
+    ActionConnectorDataType,
+    AgentConnectorDataType,
+    AgentConnectorsOutput,
+    PartialAlgorithmConfigDict,
+    PolicyState,
+    TensorStructType,
+    TensorType,
+)
+from ray.util import log_once
+from ray.util.annotations import PublicAPI
+
+if TYPE_CHECKING:
+    from ray.rllib.policy.policy import Policy
+
+logger = logging.getLogger(__name__)
+
+tf1, tf, tfv = try_import_tf()
+
+
+@PublicAPI
+def create_policy_for_framework(
+    policy_id: str,
+    policy_class: Type["Policy"],
+    merged_config: PartialAlgorithmConfigDict,
+    observation_space: gym.Space,
+    action_space: gym.Space,
+    worker_index: int = 0,
+    session_creator: Optional[Callable[[], "tf1.Session"]] = None,
+    seed: Optional[int] = None,
+):
+    """Framework-specific policy creation logics.
+
+    Args:
+        policy_id: Policy ID.
+        policy_class: Policy class type.
+        merged_config: Complete policy config.
+        observation_space: Observation space of env.
+        action_space: Action space of env.
+        worker_index: Index of worker holding this policy. Default is 0.
+        session_creator: An optional tf1.Session creation callable.
+        seed: Optional random seed.
+    """
+    from ray.rllib.algorithms.algorithm_config import AlgorithmConfig
+
+    if isinstance(merged_config, AlgorithmConfig):
+        merged_config = merged_config.to_dict()
+
+    # add policy_id to merged_config
+    merged_config["__policy_id"] = policy_id
+
+    framework = merged_config.get("framework", "tf")
+    # Tf.
+    if framework in ["tf2", "tf"]:
+        var_scope = policy_id + (f"_wk{worker_index}" if worker_index else "")
+        # For tf static graph, build every policy in its own graph
+        # and create a new session for it.
+        if framework == "tf":
+            with tf1.Graph().as_default():
+                # Session creator function provided manually -> Use this one to
+                # create the tf1 session.
+                if session_creator:
+                    sess = session_creator()
+                # Use a default session creator, based only on our `tf_session_args` in
+                # the config.
+                else:
+                    sess = tf1.Session(
+                        config=tf1.ConfigProto(**merged_config["tf_session_args"])
+                    )
+
+                with sess.as_default():
+                    # Set graph-level seed.
+                    if seed is not None:
+                        tf1.set_random_seed(seed)
+                    with tf1.variable_scope(var_scope):
+                        return policy_class(
+                            observation_space, action_space, merged_config
+                        )
+        # For tf-eager: no graph, no session.
+        else:
+            with tf1.variable_scope(var_scope):
+                return policy_class(observation_space, action_space, merged_config)
+    # Non-tf: No graph, no session.
+    else:
+        return policy_class(observation_space, action_space, merged_config)
+
+
+@PublicAPI(stability="alpha")
+def parse_policy_specs_from_checkpoint(
+    path: str,
+) -> Tuple[PartialAlgorithmConfigDict, Dict[str, PolicySpec], Dict[str, PolicyState]]:
+    """Read and parse policy specifications from a checkpoint file.
+
+    Args:
+        path: Path to a policy checkpoint.
+
+    Returns:
+        A tuple of: base policy config, dictionary of policy specs, and
+        dictionary of policy states.
+    """
+    with open(path, "rb") as f:
+        checkpoint_dict = pickle.load(f)
+    # Policy data is contained as a serialized binary blob under their
+    # ID keys.
+    w = pickle.loads(checkpoint_dict["worker"])
+
+    policy_config = w["policy_config"]
+    policy_states = w.get("policy_states", w["state"])
+    serialized_policy_specs = w["policy_specs"]
+    policy_specs = {
+        id: PolicySpec.deserialize(spec) for id, spec in serialized_policy_specs.items()
+    }
+
+    return policy_config, policy_specs, policy_states
+
+
+@PublicAPI(stability="alpha")
+def local_policy_inference(
+    policy: "Policy",
+    env_id: str,
+    agent_id: str,
+    obs: TensorStructType,
+    reward: Optional[float] = None,
+    terminated: Optional[bool] = None,
+    truncated: Optional[bool] = None,
+    info: Optional[Dict] = None,
+    explore: bool = None,
+    timestep: Optional[int] = None,
+) -> TensorStructType:
+    """Run a connector enabled policy using environment observation.
+
+    policy_inference manages policy and agent/action connectors,
+    so the user does not have to care about RNN state buffering or
+    extra fetch dictionaries.
+    Note that connectors are intentionally run separately from
+    compute_actions_from_input_dict(), so we can have the option
+    of running per-user connectors on the client side in a
+    server-client deployment.
+
+    Args:
+        policy: Policy object used in inference.
+        env_id: Environment ID. RLlib builds environments' trajectories internally with
+            connectors based on this, i.e. one trajectory per (env_id, agent_id) tuple.
+        agent_id: Agent ID. RLlib builds agents' trajectories internally with connectors
+            based on this, i.e. one trajectory per (env_id, agent_id) tuple.
+        obs: Environment observation to base the action on.
+        reward: Reward that is potentially used during inference. If not required,
+            may be left empty. Some policies have ViewRequirements that require this.
+            This can be set to zero at the first inference step - for example after
+            calling gmy.Env.reset.
+        terminated: `Terminated` flag that is potentially used during inference. If not
+            required, may be left None. Some policies have ViewRequirements that
+            require this extra information.
+        truncated: `Truncated` flag that is potentially used during inference. If not
+            required, may be left None. Some policies have ViewRequirements that
+            require this extra information.
+        info: Info that is potentially used durin inference. If not required,
+            may be left empty. Some policies have ViewRequirements that require this.
+        explore: Whether to pick an exploitation or exploration action
+            (default: None -> use self.config["explore"]).
+        timestep: The current (sampling) time step.
+
+    Returns:
+        List of outputs from policy forward pass.
+    """
+    assert (
+        policy.agent_connectors
+    ), "policy_inference only works with connector enabled policies."
+
+    __check_atari_obs_space(obs)
+
+    # Put policy in inference mode, so we don't spend time on training
+    # only transformations.
+    policy.agent_connectors.in_eval()
+    policy.action_connectors.in_eval()
+
+    # TODO(jungong) : support multiple env, multiple agent inference.
+    input_dict = {SampleBatch.NEXT_OBS: obs}
+    if reward is not None:
+        input_dict[SampleBatch.REWARDS] = reward
+    if terminated is not None:
+        input_dict[SampleBatch.TERMINATEDS] = terminated
+    if truncated is not None:
+        input_dict[SampleBatch.TRUNCATEDS] = truncated
+    if info is not None:
+        input_dict[SampleBatch.INFOS] = info
+
+    acd_list: List[AgentConnectorDataType] = [
+        AgentConnectorDataType(env_id, agent_id, input_dict)
+    ]
+    ac_outputs: List[AgentConnectorsOutput] = policy.agent_connectors(acd_list)
+    outputs = []
+    for ac in ac_outputs:
+        policy_output = policy.compute_actions_from_input_dict(
+            ac.data.sample_batch,
+            explore=explore,
+            timestep=timestep,
+        )
+
+        # Note (Kourosh): policy output is batched, the AgentConnectorDataType should
+        # not be batched during inference. This is the assumption made in AgentCollector
+        policy_output = tree.map_structure(lambda x: x[0], policy_output)
+
+        action_connector_data = ActionConnectorDataType(
+            env_id, agent_id, ac.data.raw_dict, policy_output
+        )
+
+        if policy.action_connectors:
+            acd = policy.action_connectors(action_connector_data)
+            actions = acd.output
+        else:
+            actions = policy_output[0]
+
+        outputs.append(actions)
+
+        # Notify agent connectors with this new policy output.
+        # Necessary for state buffering agent connectors, for example.
+        policy.agent_connectors.on_policy_output(action_connector_data)
+    return outputs
+
+
+@PublicAPI
+def compute_log_likelihoods_from_input_dict(
+    policy: "Policy", batch: Union[SampleBatch, Dict[str, TensorStructType]]
+):
+    """Returns log likelihood for actions in given batch for policy.
+
+    Computes likelihoods by passing the observations through the current
+    policy's `compute_log_likelihoods()` method
+
+    Args:
+        batch: The SampleBatch or MultiAgentBatch to calculate action
+            log likelihoods from. This batch/batches must contain OBS
+            and ACTIONS keys.
+
+    Returns:
+        The probabilities of the actions in the batch, given the
+        observations and the policy.
+    """
+    num_state_inputs = 0
+    for k in batch.keys():
+        if k.startswith("state_in_"):
+            num_state_inputs += 1
+    state_keys = ["state_in_{}".format(i) for i in range(num_state_inputs)]
+    log_likelihoods: TensorType = policy.compute_log_likelihoods(
+        actions=batch[SampleBatch.ACTIONS],
+        obs_batch=batch[SampleBatch.OBS],
+        state_batches=[batch[k] for k in state_keys],
+        prev_action_batch=batch.get(SampleBatch.PREV_ACTIONS),
+        prev_reward_batch=batch.get(SampleBatch.PREV_REWARDS),
+        actions_normalized=policy.config.get("actions_in_input_normalized", False),
+    )
+    return log_likelihoods
+
+
+@Deprecated(new="Policy.from_checkpoint([checkpoint path], [policy IDs]?)", error=True)
+def load_policies_from_checkpoint(path, policy_ids=None):
+    pass
+
+
+def __check_atari_obs_space(obs):
+    # TODO(Artur): Remove this after we have migrated deepmind style preprocessing into
+    #  connectors (and don't auto-wrap in RW anymore)
+    if any(
+        o.shape == ATARI_OBS_SHAPE if isinstance(o, np.ndarray) else False
+        for o in tree.flatten(obs)
+    ):
+        if log_once("warn_about_possibly_non_wrapped_atari_env"):
+            logger.warning(
+                "The observation you fed into local_policy_inference() has "
+                "dimensions (210, 160, 3), which is the standard for atari "
+                "environments. If RLlib raises an error including a related "
+                "dimensionality mismatch, you may need to use "
+                "ray.rllib.env.wrappers.atari_wrappers.wrap_deepmind to wrap "
+                "you environment."
+            )
+
+
+# @OldAPIStack
+validate_policy_id = validate_module_id

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/replay_buffers/__init__.py

@@ -0,0 +1,44 @@
+from ray.rllib.utils.replay_buffers.episode_replay_buffer import EpisodeReplayBuffer
+from ray.rllib.utils.replay_buffers.fifo_replay_buffer import FifoReplayBuffer
+from ray.rllib.utils.replay_buffers.multi_agent_mixin_replay_buffer import (
+    MultiAgentMixInReplayBuffer,
+)
+from ray.rllib.utils.replay_buffers.multi_agent_episode_buffer import (
+    MultiAgentEpisodeReplayBuffer,
+)
+from ray.rllib.utils.replay_buffers.multi_agent_prioritized_episode_buffer import (
+    MultiAgentPrioritizedEpisodeReplayBuffer,
+)
+from ray.rllib.utils.replay_buffers.multi_agent_prioritized_replay_buffer import (
+    MultiAgentPrioritizedReplayBuffer,
+)
+from ray.rllib.utils.replay_buffers.multi_agent_replay_buffer import (
+    MultiAgentReplayBuffer,
+    ReplayMode,
+)
+from ray.rllib.utils.replay_buffers.prioritized_episode_buffer import (
+    PrioritizedEpisodeReplayBuffer,
+)
+from ray.rllib.utils.replay_buffers.prioritized_replay_buffer import (
+    PrioritizedReplayBuffer,
+)
+from ray.rllib.utils.replay_buffers.replay_buffer import ReplayBuffer, StorageUnit
+from ray.rllib.utils.replay_buffers.reservoir_replay_buffer import ReservoirReplayBuffer
+from ray.rllib.utils.replay_buffers import utils
+
+__all__ = [
+    "EpisodeReplayBuffer",
+    "FifoReplayBuffer",
+    "MultiAgentEpisodeReplayBuffer",
+    "MultiAgentMixInReplayBuffer",
+    "MultiAgentPrioritizedEpisodeReplayBuffer",
+    "MultiAgentPrioritizedReplayBuffer",
+    "MultiAgentReplayBuffer",
+    "PrioritizedEpisodeReplayBuffer",
+    "PrioritizedReplayBuffer",
+    "ReplayMode",
+    "ReplayBuffer",
+    "ReservoirReplayBuffer",
+    "StorageUnit",
+    "utils",
+]

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/replay_buffers/fifo_replay_buffer.py

@@ -0,0 +1,109 @@
+import numpy as np
+from typing import Any, Dict, Optional
+
+from ray.rllib.policy.sample_batch import MultiAgentBatch
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.replay_buffers.replay_buffer import ReplayBuffer, StorageUnit
+from ray.rllib.utils.typing import SampleBatchType
+from ray.util.annotations import DeveloperAPI
+
+
+@DeveloperAPI
+class FifoReplayBuffer(ReplayBuffer):
+    """This replay buffer implements a FIFO queue.
+
+    Sometimes, e.g. for offline use cases, it may be desirable to use
+    off-policy algorithms without a Replay Buffer.
+    This FifoReplayBuffer can be used in-place to achieve the same effect
+    without having to introduce separate algorithm execution branches.
+
+    For simplicity and efficiency reasons, this replay buffer stores incoming
+    sample batches as-is, and returns them one at time.
+    This is to avoid any additional load when this replay buffer is used.
+    """
+
+    def __init__(self, *args, **kwargs):
+        """Initializes a FifoReplayBuffer.
+
+        Args:
+            ``*args``   : Forward compatibility args.
+            ``**kwargs``: Forward compatibility kwargs.
+        """
+        # Completely by-passing underlying ReplayBuffer by setting its
+        # capacity to 1 (lowest allowed capacity).
+        ReplayBuffer.__init__(self, 1, StorageUnit.FRAGMENTS, **kwargs)
+
+        self._queue = []
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def add(self, batch: SampleBatchType, **kwargs) -> None:
+        return self._queue.append(batch)
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def sample(self, *args, **kwargs) -> Optional[SampleBatchType]:
+        """Sample a saved training batch from this buffer.
+
+        Args:
+            ``*args``   : Forward compatibility args.
+            ``**kwargs``: Forward compatibility kwargs.
+
+        Returns:
+            A single training batch from the queue.
+        """
+        if len(self._queue) <= 0:
+            # Return empty SampleBatch if queue is empty.
+            return MultiAgentBatch({}, 0)
+        batch = self._queue.pop(0)
+        # Equal weights of 1.0.
+        batch["weights"] = np.ones(len(batch))
+        return batch
+
+    @DeveloperAPI
+    def update_priorities(self, *args, **kwargs) -> None:
+        """Update priorities of items at given indices.
+
+        No-op for this replay buffer.
+
+        Args:
+            ``*args``   : Forward compatibility args.
+            ``**kwargs``: Forward compatibility kwargs.
+        """
+        pass
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def stats(self, debug: bool = False) -> Dict:
+        """Returns the stats of this buffer.
+
+        Args:
+            debug: If true, adds sample eviction statistics to the returned stats dict.
+
+        Returns:
+            A dictionary of stats about this buffer.
+        """
+        # As if this replay buffer has never existed.
+        return {}
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def get_state(self) -> Dict[str, Any]:
+        """Returns all local state.
+
+        Returns:
+            The serializable local state.
+        """
+        # Pass through replay buffer does not save states.
+        return {}
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def set_state(self, state: Dict[str, Any]) -> None:
+        """Restores all local state to the provided `state`.
+
+        Args:
+            state: The new state to set this buffer. Can be obtained by calling
+            `self.get_state()`.
+        """
+        pass

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/replay_buffers/multi_agent_episode_buffer.py

@@ -0,0 +1,1026 @@
+import copy
+from collections import defaultdict, deque
+from gymnasium.core import ActType, ObsType
+import numpy as np
+import scipy
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
+
+from ray.rllib.core.columns import Columns
+from ray.rllib.env.multi_agent_episode import MultiAgentEpisode
+from ray.rllib.env.single_agent_episode import SingleAgentEpisode
+from ray.rllib.utils.replay_buffers.episode_replay_buffer import EpisodeReplayBuffer
+from ray.rllib.utils import force_list
+from ray.rllib.utils.annotations import override, DeveloperAPI
+from ray.rllib.utils.spaces.space_utils import batch
+from ray.rllib.utils.typing import AgentID, ModuleID, SampleBatchType
+
+
+@DeveloperAPI
+class MultiAgentEpisodeReplayBuffer(EpisodeReplayBuffer):
+    """Multi-agent episode replay buffer that stores episodes by their IDs.
+
+    This class implements a replay buffer as used in "playing Atari with Deep
+    Reinforcement Learning" (Mnih et al., 2013) for multi-agent reinforcement
+    learning,
+
+    Each "row" (a slot in a deque) in the buffer is occupied by one episode. If an
+    incomplete episode is added to the buffer and then another chunk of that episode is
+    added at a later time, the buffer will automatically concatenate the new fragment to
+    the original episode. This way, episodes can be completed via subsequent `add`
+    calls.
+
+    Sampling returns a size `B` episode list (number of 'rows'), where each episode
+    holds a tuple tuple of the form
+
+    `(o_t, a_t, sum(r_t+1:t+n), o_t+n)`
+
+    where `o_t` is the observation in `t`, `a_t` the action chosen at observation `o_t`,
+    `o_t+n` is the observation `n` timesteps later and `sum(r_t+1:t+n)` is the sum of
+    all rewards collected over the time steps between `t+1` and `t+n`. The `n`-step can
+    be chosen freely when sampling and defaults to `1`. If `n_step` is a tuple it is
+    sampled uniformly across the interval defined by the tuple (for each row in the
+    batch).
+
+    Each episode contains - in addition to the data tuples presented above - two further
+    elements in its `extra_model_outputs`, namely `n_steps` and `weights`. The former
+    holds the `n_step` used for the sampled timesteps in the episode and the latter the
+    corresponding (importance sampling) weight for the transition.
+
+    .. testcode::
+
+        import gymnasium as gym
+
+        from ray.rllib.env.multi_agent_episode import MultiAgentEpisode
+        from ray.rllib.examples.envs.classes.multi_agent import MultiAgentCartPole
+        from ray.rllib.utils.replay_buffers import MultiAgentEpisodeReplayBuffer
+
+
+        # Create the environment.
+        env = MultiAgentCartPole({"num_agents": 2})
+
+        # Set up the loop variables
+        agent_ids = env.agents
+        agent_ids.append("__all__")
+        terminateds = {aid: False for aid in agent_ids}
+        truncateds = {aid: False for aid in agent_ids}
+        num_timesteps = 10000
+        episodes = []
+
+        # Initialize the first episode entries.
+        eps = MultiAgentEpisode()
+        obs, infos = env.reset()
+        eps.add_env_reset(observations=obs, infos=infos)
+
+        # Sample 10,000 env timesteps.
+        for i in range(num_timesteps):
+            # If terminated we create a new episode.
+            if eps.is_done:
+                episodes.append(eps.finalize())
+                eps = MultiAgentEpisode()
+                terminateds = {aid: False for aid in agent_ids}
+                truncateds = {aid: False for aid in agent_ids}
+                obs, infos = env.reset()
+                eps.add_env_reset(observations=obs, infos=infos)
+
+            # Sample a random action for all agents that should step in the episode
+            # next.
+            actions = {
+                aid: env.get_action_space(aid).sample()
+                for aid in eps.get_agents_to_act()
+            }
+            obs, rewards, terminateds, truncateds, infos = env.step(actions)
+            eps.add_env_step(
+                obs,
+                actions,
+                rewards,
+                infos,
+                terminateds=terminateds,
+                truncateds=truncateds
+            )
+
+        # Add the last (truncated) episode to the list of episodes.
+        if not eps.is_done:
+            episodes.append(eps)
+
+        # Create the buffer.
+        buffer = MultiAgentEpisodeReplayBuffer()
+        # Add the list of episodes sampled.
+        buffer.add(episodes)
+
+        # Pull a sample from the buffer using an `n-step` of 3.
+        sample = buffer.sample(num_items=256, gamma=0.95, n_step=3)
+    """
+
+    def __init__(
+        self,
+        capacity: int = 10000,
+        *,
+        batch_size_B: int = 16,
+        batch_length_T: int = 1,
+        **kwargs,
+    ):
+        """Initializes a multi-agent episode replay buffer.
+
+        Args:
+            capacity: The total number of timesteps to be storable in this buffer.
+                Will start ejecting old episodes once this limit is reached.
+            batch_size_B: The number of episodes returned from `sample()`.
+            batch_length_T: The length of each episode in the episode list returned from
+                `sample()`.
+        """
+        # Initialize the base episode replay buffer.
+        super().__init__(
+            capacity=capacity,
+            batch_size_B=batch_size_B,
+            batch_length_T=batch_length_T,
+            **kwargs,
+        )
+
+        # Stores indices of module (single-agent) timesteps. Each index is a tuple
+        # of the form:
+        #   `(ma_episode_idx, agent_id, timestep)`.
+        # This information is stored for each timestep of an episode and is used in
+        # the `"independent"`` sampling process. The multi-agent episode index amd the
+        # agent ID are used to retrieve the single-agent episode. The timestep is then
+        # needed to retrieve the corresponding timestep data from that single-agent
+        # episode.
+        self._module_to_indices: Dict[
+            ModuleID, List[Tuple[int, AgentID, int]]
+        ] = defaultdict(list)
+
+        # Stores the number of single-agent timesteps in the buffer.
+        self._num_agent_timesteps: int = 0
+        # Stores the number of single-agent timesteps per module.
+        self._num_module_timesteps: Dict[ModuleID, int] = defaultdict(int)
+
+        # Stores the number of added single-agent timesteps over the
+        # lifetime of the buffer.
+        self._num_agent_timesteps_added: int = 0
+        # Stores the number of added single-agent timesteps per module
+        # over the lifetime of the buffer.
+        self._num_module_timesteps_added: Dict[ModuleID, int] = defaultdict(int)
+
+        self._num_module_episodes: Dict[ModuleID, int] = defaultdict(int)
+        # Stores the number of module episodes evicted. Note, this is
+        # important for indexing.
+        self._num_module_episodes_evicted: Dict[ModuleID, int] = defaultdict(int)
+
+        # Stores hte number of module timesteps sampled.
+        self.sampled_timesteps_per_module: Dict[ModuleID, int] = defaultdict(int)
+
+    @override(EpisodeReplayBuffer)
+    def add(
+        self,
+        episodes: Union[List["MultiAgentEpisode"], "MultiAgentEpisode"],
+    ) -> None:
+        """Adds episodes to the replay buffer.
+
+        Note, if the incoming episodes' time steps cause the buffer to overflow,
+        older episodes are evicted. Because episodes usually come in chunks and
+        not complete, this could lead to edge cases (e.g. with very small capacity
+        or very long episode length) where the first part of an episode is evicted
+        while the next part just comes in.
+        To defend against such case, the complete episode is evicted, including
+        the new chunk, unless the episode is the only one in the buffer. In the
+        latter case the buffer will be allowed to overflow in a temporary fashion,
+        i.e. during the next addition of samples to the buffer an attempt is made
+        to fall below capacity again.
+
+        The user is advised to select a large enough buffer with regard to the maximum
+        expected episode length.
+
+        Args:
+            episodes: The multi-agent episodes to add to the replay buffer. Can be a
+                single episode or a list of episodes.
+        """
+        episodes: List["MultiAgentEpisode"] = force_list(episodes)
+
+        new_episode_ids: Set[str] = {eps.id_ for eps in episodes}
+        total_env_timesteps = sum([eps.env_steps() for eps in episodes])
+        self._num_timesteps += total_env_timesteps
+        self._num_timesteps_added += total_env_timesteps
+
+        # Evict old episodes.
+        eps_evicted_ids: Set[Union[str, int]] = set()
+        eps_evicted_idxs: Set[int] = set()
+        while (
+            self._num_timesteps > self.capacity
+            and self._num_remaining_episodes(new_episode_ids, eps_evicted_ids) != 1
+        ):
+            # Evict episode.
+            evicted_episode = self.episodes.popleft()
+            eps_evicted_ids.add(evicted_episode.id_)
+            eps_evicted_idxs.add(self.episode_id_to_index.pop(evicted_episode.id_))
+            # If this episode has a new chunk in the new episodes added,
+            # we subtract it again.
+            # TODO (sven, simon): Should we just treat such an episode chunk
+            # as a new episode?
+            if evicted_episode.id_ in new_episode_ids:
+                idx = next(
+                    i
+                    for i, eps in enumerate(episodes)
+                    if eps.id_ == evicted_episode.id_
+                )
+                new_eps_to_evict = episodes.pop(idx)
+                self._num_timesteps -= new_eps_to_evict.env_steps()
+                self._num_timesteps_added -= new_eps_to_evict.env_steps()
+            # Remove the timesteps of the evicted episode from the counter.
+            self._num_timesteps -= evicted_episode.env_steps()
+            self._num_agent_timesteps -= evicted_episode.agent_steps()
+            self._num_episodes_evicted += 1
+            # Remove the module timesteps of the evicted episode from the counters.
+            self._evict_module_episodes(evicted_episode)
+            del evicted_episode
+
+        # Add agent and module steps.
+        for eps in episodes:
+            self._num_agent_timesteps += eps.agent_steps()
+            self._num_agent_timesteps_added += eps.agent_steps()
+            # Update the module counters by the module timesteps.
+            self._update_module_counters(eps)
+
+        # Remove corresponding indices, if episodes were evicted.
+        if eps_evicted_idxs:
+            # If the episode is not exvicted, we keep the index.
+            # Note, ach index 2-tuple is of the form (ma_episode_idx, timestep) and
+            # refers to a certain environment timestep in a certain multi-agent
+            # episode.
+            self._indices = [
+                idx_tuple
+                for idx_tuple in self._indices
+                if idx_tuple[0] not in eps_evicted_idxs
+            ]
+            # Also remove corresponding module indices.
+            for module_id, module_indices in self._module_to_indices.items():
+                # Each index 3-tuple is of the form
+                # (ma_episode_idx, agent_id, timestep) and refers to a certain
+                # agent timestep in a certain multi-agent episode.
+                self._module_to_indices[module_id] = [
+                    idx_triplet
+                    for idx_triplet in module_indices
+                    if idx_triplet[0] not in eps_evicted_idxs
+                ]
+
+        for eps in episodes:
+            eps = copy.deepcopy(eps)
+            # If the episode is part of an already existing episode, concatenate.
+            if eps.id_ in self.episode_id_to_index:
+                eps_idx = self.episode_id_to_index[eps.id_]
+                existing_eps = self.episodes[eps_idx - self._num_episodes_evicted]
+                existing_len = len(existing_eps)
+                self._indices.extend(
+                    [
+                        (
+                            eps_idx,
+                            existing_len + i,
+                        )
+                        for i in range(len(eps))
+                    ]
+                )
+                # Add new module indices.
+                self._add_new_module_indices(eps, eps_idx, True)
+                # Concatenate the episode chunk.
+                existing_eps.concat_episode(eps)
+            # Otherwise, create a new entry.
+            else:
+                # New episode.
+                self.episodes.append(eps)
+                eps_idx = len(self.episodes) - 1 + self._num_episodes_evicted
+                self.episode_id_to_index[eps.id_] = eps_idx
+                self._indices.extend([(eps_idx, i) for i in range(len(eps))])
+                # Add new module indices.
+                self._add_new_module_indices(eps, eps_idx, False)
+
+    @override(EpisodeReplayBuffer)
+    def sample(
+        self,
+        num_items: Optional[int] = None,
+        *,
+        batch_size_B: Optional[int] = None,
+        batch_length_T: Optional[int] = None,
+        n_step: Optional[Union[int, Tuple]] = 1,
+        gamma: float = 0.99,
+        include_infos: bool = False,
+        include_extra_model_outputs: bool = False,
+        replay_mode: str = "independent",
+        modules_to_sample: Optional[List[ModuleID]] = None,
+        **kwargs,
+    ) -> Union[List["MultiAgentEpisode"], List["SingleAgentEpisode"]]:
+        """Samples a batch of multi-agent transitions.
+
+        Multi-agent transitions can be sampled either `"independent"` or
+        `"synchronized"` with the former sampling for each module independent agent
+        steps and the latter sampling agent transitions from the same environment step.
+
+        The n-step parameter can be either a single integer or a tuple of two integers.
+        In the former case, the n-step is fixed to the given integer and in the latter
+        case, the n-step is sampled uniformly from the given range. Large n-steps could
+        potentially lead to a many retries because not all samples might have a full
+        n-step transition.
+
+        Sampling returns batches of size B (number of 'rows'), where each row is a tuple
+        of the form
+
+        `(o_t, a_t, sum(r_t+1:t+n), o_t+n)`
+
+        where `o_t` is the observation in `t`, `a_t` the action chosen at observation
+        `o_t`, `o_t+n` is the observation `n` timesteps later and `sum(r_t+1:t+n)` is
+        the sum of all rewards collected over the time steps between `t+1` and `t+n`.
+        The n`-step can be chosen freely when sampling and defaults to `1`. If `n_step`
+        is a tuple it is sampled uniformly across the interval defined by the tuple (for
+        each row in the batch).
+
+        Each batch contains - in addition to the data tuples presented above - two
+        further columns, namely `n_steps` and `weigths`. The former holds the `n_step`
+        used for each row in the batch and the latter a (default) weight of `1.0` for
+        each row in the batch. This weight is used for weighted loss calculations in
+        the training process.
+
+        Args:
+            num_items: The number of items to sample. If provided, `batch_size_B`
+                should be `None`.
+            batch_size_B: The batch size to sample. If provided, `num_items`
+                should be `None`.
+            batch_length_T: The length of the sampled batch. If not provided, the
+                default batch length is used. This feature is not yet implemented.
+            n_step: The n-step to sample. If the n-step is a tuple, the n-step is
+                sampled uniformly from the given range. If not provided, the default
+                n-step of `1` is used.
+            gamma: The discount factor for the n-step reward calculation.
+            include_infos: Whether to include the infos in the sampled batch.
+            include_extra_model_outputs: Whether to include the extra model outputs
+                in the sampled batch.
+            replay_mode: The replay mode to use for sampling. Either `"independent"`
+                or `"synchronized"`.
+            modules_to_sample: A list of module IDs to sample from. If not provided,
+                transitions for aall modules are sampled.
+
+        Returns:
+            A dictionary of the form `ModuleID -> SampleBatchType` containing the
+            sampled data for each module or each module in `modules_to_sample`,
+            if provided.
+        """
+        if num_items is not None:
+            assert batch_size_B is None, (
+                "Cannot call `sample()` with both `num_items` and `batch_size_B` "
+                "provided! Use either one."
+            )
+            batch_size_B = num_items
+
+        # Use our default values if no sizes/lengths provided.
+        batch_size_B = batch_size_B or self.batch_size_B
+        # TODO (simon): Implement trajectory sampling for RNNs.
+        batch_length_T = batch_length_T or self.batch_length_T
+
+        # Sample for each module independently.
+        if replay_mode == "independent":
+            return self._sample_independent(
+                batch_size_B=batch_size_B,
+                batch_length_T=batch_length_T,
+                n_step=n_step,
+                gamma=gamma,
+                include_infos=include_infos,
+                include_extra_model_outputs=include_extra_model_outputs,
+                modules_to_sample=modules_to_sample,
+            )
+        else:
+            return self._sample_synchonized(
+                batch_size_B=batch_size_B,
+                batch_length_T=batch_length_T,
+                n_step=n_step,
+                gamma=gamma,
+                include_infos=include_infos,
+                include_extra_model_outputs=include_extra_model_outputs,
+                modules_to_sample=modules_to_sample,
+            )
+
+    def get_added_agent_timesteps(self) -> int:
+        """Returns number of agent timesteps that have been added in buffer's lifetime.
+
+        Note, this could be more than the `get_added_timesteps` returns as an
+        environment timestep could contain multiple agent timesteps (for eaxch agent
+        one).
+        """
+        return self._num_agent_timesteps_added
+
+    def get_module_ids(self) -> List[ModuleID]:
+        """Returns a list of module IDs stored in the buffer."""
+        return list(self._module_to_indices.keys())
+
+    def get_num_agent_timesteps(self) -> int:
+        """Returns number of agent timesteps stored in the buffer.
+
+        Note, this could be more than the `num_timesteps` as an environment timestep
+        could contain multiple agent timesteps (for eaxch agent one).
+        """
+        return self._num_agent_timesteps
+
+    @override(EpisodeReplayBuffer)
+    def get_num_episodes(self, module_id: Optional[ModuleID] = None) -> int:
+        """Returns number of episodes stored for a module in the buffer.
+
+        Note, episodes could be either complete or truncated.
+
+        Args:
+            module_id: The ID of the module to query. If not provided, the number of
+                episodes for all modules is returned.
+
+        Returns:
+            The number of episodes stored for the module or all modules.
+        """
+        return (
+            self._num_module_episodes[module_id]
+            if module_id
+            else super().get_num_episodes()
+        )
+
+    @override(EpisodeReplayBuffer)
+    def get_num_episodes_evicted(self, module_id: Optional[ModuleID] = None) -> int:
+        """Returns number of episodes evicted for a module in the buffer."""
+        return (
+            self._num_module_episodes_evicted[module_id]
+            if module_id
+            else super().get_num_episodes_evicted()
+        )
+
+    @override(EpisodeReplayBuffer)
+    def get_num_timesteps(self, module_id: Optional[ModuleID] = None) -> int:
+        """Returns number of individual timesteps for a module stored in the buffer.
+
+        Args:
+            module_id: The ID of the module to query. If not provided, the number of
+                timesteps for all modules are returned.
+
+        Returns:
+            The number of timesteps stored for the module or all modules.
+        """
+        return (
+            self._num_module_timesteps[module_id]
+            if module_id
+            else super().get_num_timesteps()
+        )
+
+    @override(EpisodeReplayBuffer)
+    def get_sampled_timesteps(self, module_id: Optional[ModuleID] = None) -> int:
+        """Returns number of timesteps that have been sampled for a module.
+
+        Args:
+            module_id: The ID of the module to query. If not provided, the number of
+                sampled timesteps for all modules are returned.
+
+        Returns:
+            The number of timesteps sampled for the module or all modules.
+        """
+        return (
+            self.sampled_timesteps_per_module[module_id]
+            if module_id
+            else super().get_sampled_timesteps()
+        )
+
+    @override(EpisodeReplayBuffer)
+    def get_added_timesteps(self, module_id: Optional[ModuleID] = None) -> int:
+        """Returns the number of timesteps added in buffer's lifetime for given module.
+
+        Args:
+            module_id: The ID of the module to query. If not provided, the total number
+                of timesteps ever added.
+
+        Returns:
+            The number of timesteps added for `module_id` (or all modules if `module_id`
+            is None).
+        """
+        return (
+            self._num_module_timesteps_added[module_id]
+            if module_id
+            else super().get_added_timesteps()
+        )
+
+    @override(EpisodeReplayBuffer)
+    def get_state(self) -> Dict[str, Any]:
+        """Gets a pickable state of the buffer.
+
+        This is used for checkpointing the buffer's state. It is specifically helpful,
+        for example, when a trial is paused and resumed later on. The buffer's state
+        can be saved to disk and reloaded when the trial is resumed.
+
+        Returns:
+            A dict containing all necessary information to restore the buffer's state.
+        """
+        return super().get_state() | {
+            "_module_to_indices": list(self._module_to_indices.items()),
+            "_num_agent_timesteps": self._num_agent_timesteps,
+            "_num_agent_timesteps_added": self._num_agent_timesteps_added,
+            "_num_module_timesteps": list(self._num_module_timesteps.items()),
+            "_num_module_timesteps_added": list(
+                self._num_module_timesteps_added.items()
+            ),
+            "_num_module_episodes": list(self._num_module_episodes.items()),
+            "_num_module_episodes_evicted": list(
+                self._num_module_episodes_evicted.items()
+            ),
+            "sampled_timesteps_per_module": list(
+                self.sampled_timesteps_per_module.items()
+            ),
+        }
+
+    @override(EpisodeReplayBuffer)
+    def set_state(self, state) -> None:
+        """Sets the state of a buffer from a previously stored state.
+
+        See `get_state()` for more information on what is stored in the state. This
+        method is used to restore the buffer's state from a previously stored state.
+        It is specifically helpful, for example, when a trial is paused and resumed
+        later on. The buffer's state can be saved to disk and reloaded when the trial
+        is resumed.
+
+        Args:
+            state: The state to restore the buffer from.
+        """
+        # Set the episodes.
+        self._set_episodes(state)
+        # Set the super's state.
+        super().set_state(state)
+        # Now set the remaining attributes.
+        self._module_to_indices = defaultdict(list, dict(state["_module_to_indices"]))
+        self._num_agent_timesteps = state["_num_agent_timesteps"]
+        self._num_agent_timesteps_added = state["_num_agent_timesteps_added"]
+        self._num_module_timesteps = defaultdict(
+            int, dict(state["_num_module_timesteps"])
+        )
+        self._num_module_timesteps_added = defaultdict(
+            int, dict(state["_num_module_timesteps_added"])
+        )
+        self._num_module_episodes = defaultdict(
+            int, dict(state["_num_module_episodes"])
+        )
+        self._num_module_episodes_evicted = defaultdict(
+            int, dict(state["_num_module_episodes_evicted"])
+        )
+        self.sampled_timesteps_per_module = defaultdict(
+            list, dict(state["sampled_timesteps_per_module"])
+        )
+
+    def _set_episodes(self, state: Dict[str, Any]) -> None:
+        """Sets the episodes from the state."""
+        if not self.episodes:
+            self.episodes = deque(
+                [
+                    MultiAgentEpisode.from_state(eps_data)
+                    for eps_data in state["episodes"]
+                ]
+            )
+
+    def _sample_independent(
+        self,
+        batch_size_B: Optional[int],
+        batch_length_T: Optional[int],
+        n_step: Optional[Union[int, Tuple[int, int]]],
+        gamma: float,
+        include_infos: bool,
+        include_extra_model_outputs: bool,
+        modules_to_sample: Optional[Set[ModuleID]],
+    ) -> List["SingleAgentEpisode"]:
+        """Samples a batch of independent multi-agent transitions."""
+
+        actual_n_step = n_step or 1
+        # Sample the n-step if necessary.
+        random_n_step = isinstance(n_step, (tuple, list))
+
+        sampled_episodes = []
+        # TODO (simon): Ensure that the module has data and if not, skip it.
+        #  TODO (sven): Should we then error out or skip? I think the Learner
+        #  should handle this case when a module has no train data.
+        modules_to_sample = modules_to_sample or set(self._module_to_indices.keys())
+        for module_id in modules_to_sample:
+            module_indices = self._module_to_indices[module_id]
+            B = 0
+            while B < batch_size_B:
+                # Now sample from the single-agent timesteps.
+                index_tuple = module_indices[self.rng.integers(len(module_indices))]
+
+                # This will be an agent timestep (not env timestep).
+                # TODO (simon, sven): Maybe deprecate sa_episode_idx (_) in the index
+                #   quads. Is there any need for it?
+                ma_episode_idx, agent_id, sa_episode_ts = (
+                    index_tuple[0] - self._num_episodes_evicted,
+                    index_tuple[1],
+                    index_tuple[2],
+                )
+
+                # Get the multi-agent episode.
+                ma_episode = self.episodes[ma_episode_idx]
+                # Retrieve the single-agent episode for filtering.
+                sa_episode = ma_episode.agent_episodes[agent_id]
+
+                # If we use random n-step sampling, draw the n-step for this item.
+                if random_n_step:
+                    actual_n_step = int(self.rng.integers(n_step[0], n_step[1]))
+                # If we cannnot make the n-step, we resample.
+                if sa_episode_ts + actual_n_step > len(sa_episode):
+                    continue
+                # Note, this will be the reward after executing action
+                # `a_(episode_ts)`. For `n_step>1` this will be the discounted sum
+                # of all rewards that were collected over the last n steps.
+                sa_raw_rewards = sa_episode.get_rewards(
+                    slice(sa_episode_ts, sa_episode_ts + actual_n_step)
+                )
+                sa_rewards = scipy.signal.lfilter(
+                    [1], [1, -gamma], sa_raw_rewards[::-1], axis=0
+                )[-1]
+
+                sampled_sa_episode = SingleAgentEpisode(
+                    id_=sa_episode.id_,
+                    # Provide the IDs for the learner connector.
+                    agent_id=sa_episode.agent_id,
+                    module_id=sa_episode.module_id,
+                    multi_agent_episode_id=ma_episode.id_,
+                    # Ensure that each episode contains a tuple of the form:
+                    #   (o_t, a_t, sum(r_(t:t+n_step)), o_(t+n_step))
+                    # Two observations (t and t+n).
+                    observations=[
+                        sa_episode.get_observations(sa_episode_ts),
+                        sa_episode.get_observations(sa_episode_ts + actual_n_step),
+                    ],
+                    observation_space=sa_episode.observation_space,
+                    infos=(
+                        [
+                            sa_episode.get_infos(sa_episode_ts),
+                            sa_episode.get_infos(sa_episode_ts + actual_n_step),
+                        ]
+                        if include_infos
+                        else None
+                    ),
+                    actions=[sa_episode.get_actions(sa_episode_ts)],
+                    action_space=sa_episode.action_space,
+                    rewards=[sa_rewards],
+                    # If the sampled single-agent episode is the single-agent episode's
+                    # last time step, check, if the single-agent episode is terminated
+                    # or truncated.
+                    terminated=(
+                        sa_episode_ts + actual_n_step >= len(sa_episode)
+                        and sa_episode.is_terminated
+                    ),
+                    truncated=(
+                        sa_episode_ts + actual_n_step >= len(sa_episode)
+                        and sa_episode.is_truncated
+                    ),
+                    extra_model_outputs={
+                        "weights": [1.0],
+                        "n_step": [actual_n_step],
+                        **(
+                            {
+                                k: [
+                                    sa_episode.get_extra_model_outputs(k, sa_episode_ts)
+                                ]
+                                for k in sa_episode.extra_model_outputs.keys()
+                            }
+                            if include_extra_model_outputs
+                            else {}
+                        ),
+                    },
+                    # TODO (sven): Support lookback buffers.
+                    len_lookback_buffer=0,
+                    t_started=sa_episode_ts,
+                )
+                # Append single-agent episode to the list of sampled episodes.
+                sampled_episodes.append(sampled_sa_episode)
+
+                # Increase counter.
+                B += 1
+
+            # Increase the per module timesteps counter.
+            self.sampled_timesteps_per_module[module_id] += B
+
+        # Increase the counter for environment timesteps.
+        self.sampled_timesteps += batch_size_B
+        # Return multi-agent dictionary.
+        return sampled_episodes
+
+    def _sample_synchonized(
+        self,
+        batch_size_B: Optional[int],
+        batch_length_T: Optional[int],
+        n_step: Optional[Union[int, Tuple]],
+        gamma: float,
+        include_infos: bool,
+        include_extra_model_outputs: bool,
+        modules_to_sample: Optional[List[ModuleID]],
+    ) -> SampleBatchType:
+        """Samples a batch of synchronized multi-agent transitions."""
+        # Sample the n-step if necessary.
+        if isinstance(n_step, tuple):
+            # Use random n-step sampling.
+            random_n_step = True
+        else:
+            actual_n_step = n_step or 1
+            random_n_step = False
+
+        # Containers for the sampled data.
+        observations: Dict[ModuleID, List[ObsType]] = defaultdict(list)
+        next_observations: Dict[ModuleID, List[ObsType]] = defaultdict(list)
+        actions: Dict[ModuleID, List[ActType]] = defaultdict(list)
+        rewards: Dict[ModuleID, List[float]] = defaultdict(list)
+        is_terminated: Dict[ModuleID, List[bool]] = defaultdict(list)
+        is_truncated: Dict[ModuleID, List[bool]] = defaultdict(list)
+        weights: Dict[ModuleID, List[float]] = defaultdict(list)
+        n_steps: Dict[ModuleID, List[int]] = defaultdict(list)
+        # If `info` should be included, construct also a container for them.
+        if include_infos:
+            infos: Dict[ModuleID, List[Dict[str, Any]]] = defaultdict(list)
+        # If `extra_model_outputs` should be included, construct a container for them.
+        if include_extra_model_outputs:
+            extra_model_outputs: Dict[ModuleID, List[Dict[str, Any]]] = defaultdict(
+                list
+            )
+
+        B = 0
+        while B < batch_size_B:
+            index_tuple = self._indices[self.rng.integers(len(self._indices))]
+
+            # This will be an env timestep (not agent timestep)
+            ma_episode_idx, ma_episode_ts = (
+                index_tuple[0] - self._num_episodes_evicted,
+                index_tuple[1],
+            )
+            # If we use random n-step sampling, draw the n-step for this item.
+            if random_n_step:
+                actual_n_step = int(self.rng.integers(n_step[0], n_step[1]))
+            # If we are at the end of an episode, continue.
+            # Note, priority sampling got us `o_(t+n)` and we need for the loss
+            # calculation in addition `o_t`.
+            # TODO (simon): Maybe introduce a variable `num_retries` until the
+            # while loop should break when not enough samples have been collected
+            # to make n-step possible.
+            if ma_episode_ts - actual_n_step < 0:
+                continue
+
+            # Retrieve the multi-agent episode.
+            ma_episode = self.episodes[ma_episode_idx]
+
+            # Ensure that each row contains a tuple of the form:
+            #   (o_t, a_t, sum(r_(t:t+n_step)), o_(t+n_step))
+            # TODO (simon): Implement version for sequence sampling when using RNNs.
+            eps_observation = ma_episode.get_observations(
+                slice(ma_episode_ts - actual_n_step, ma_episode_ts + 1),
+                return_list=True,
+            )
+            # Note, `MultiAgentEpisode` stores the action that followed
+            # `o_t` with `o_(t+1)`, therefore, we need the next one.
+            # TODO (simon): This gets the wrong action as long as the getters are not
+            # fixed.
+            eps_actions = ma_episode.get_actions(ma_episode_ts - actual_n_step)
+            # Make sure that at least a single agent should have full transition.
+            # TODO (simon): Filter for the `modules_to_sample`.
+            agents_to_sample = self._agents_with_full_transitions(
+                eps_observation,
+                eps_actions,
+            )
+            # If not, we resample.
+            if not agents_to_sample:
+                continue
+            # TODO (simon, sven): Do we need to include the common agent rewards?
+            # Note, the reward that is collected by transitioning from `o_t` to
+            # `o_(t+1)` is stored in the next transition in `MultiAgentEpisode`.
+            eps_rewards = ma_episode.get_rewards(
+                slice(ma_episode_ts - actual_n_step, ma_episode_ts),
+                return_list=True,
+            )
+            # TODO (simon, sven): Do we need to include the common infos? And are
+            # there common extra model outputs?
+            if include_infos:
+                # If infos are included we include the ones from the last timestep
+                # as usually the info contains additional values about the last state.
+                eps_infos = ma_episode.get_infos(ma_episode_ts)
+            if include_extra_model_outputs:
+                # If `extra_model_outputs` are included we include the ones from the
+                # first timestep as usually the `extra_model_outputs` contain additional
+                # values from the forward pass that produced the action at the first
+                # timestep.
+                # Note, we extract them into single row dictionaries similar to the
+                # infos, in a connector we can then extract these into single batch
+                # rows.
+                eps_extra_model_outputs = {
+                    k: ma_episode.get_extra_model_outputs(
+                        k, ma_episode_ts - actual_n_step
+                    )
+                    for k in ma_episode.extra_model_outputs.keys()
+                }
+            # If the sampled time step is the episode's last time step check, if
+            # the episode is terminated or truncated.
+            episode_terminated = False
+            episode_truncated = False
+            if ma_episode_ts == ma_episode.env_t:
+                episode_terminated = ma_episode.is_terminated
+                episode_truncated = ma_episode.is_truncated
+            # TODO (simon): Filter for the `modules_to_sample`.
+            # TODO (sven, simon): We could here also sample for all agents in the
+            # `modules_to_sample` and then adapt the `n_step` for agents that
+            # have not a full transition.
+            for agent_id in agents_to_sample:
+                # Map our agent to the corresponding module we want to
+                # train.
+                module_id = ma_episode._agent_to_module_mapping[agent_id]
+                # Sample only for the modules in `modules_to_sample`.
+                if module_id not in (
+                    modules_to_sample or self._module_to_indices.keys()
+                ):
+                    continue
+                # TODO (simon, sven): Here we could skip for modules not
+                # to be sampled in `modules_to_sample`.
+                observations[module_id].append(eps_observation[0][agent_id])
+                next_observations[module_id].append(eps_observation[-1][agent_id])
+                # Fill missing rewards with zeros.
+                agent_rewards = [r[agent_id] or 0.0 for r in eps_rewards]
+                rewards[module_id].append(
+                    scipy.signal.lfilter([1], [1, -gamma], agent_rewards[::-1], axis=0)[
+                        -1
+                    ]
+                )
+                # Note, this should exist, as we filtered for agents with full
+                # transitions.
+                actions[module_id].append(eps_actions[agent_id])
+                if include_infos:
+                    infos[module_id].append(eps_infos[agent_id])
+                if include_extra_model_outputs:
+                    extra_model_outputs[module_id].append(
+                        {
+                            k: eps_extra_model_outputs[agent_id][k]
+                            for k in eps_extra_model_outputs[agent_id].keys()
+                        }
+                    )
+                # If sampled observation is terminal for the agent. Either MAE
+                # episode is truncated/terminated or SAE episode is truncated/
+                # terminated at this ts.
+                # TODO (simon, sven): Add method agent_alive(ts) to MAE.
+                # or add slicing to get_terminateds().
+                agent_ts = ma_episode.env_t_to_agent_t[agent_id][ma_episode_ts]
+                agent_eps = ma_episode.agent_episodes[agent_id]
+                agent_terminated = agent_ts == agent_eps.t and agent_eps.is_terminated
+                agent_truncated = (
+                    agent_ts == agent_eps.t
+                    and agent_eps.is_truncated
+                    and not agent_eps.is_terminated
+                )
+                if episode_terminated or agent_terminated:
+                    is_terminated[module_id].append(True)
+                    is_truncated[module_id].append(False)
+                elif episode_truncated or agent_truncated:
+                    is_truncated[module_id].append(True)
+                    is_terminated[module_id].append(False)
+                else:
+                    is_terminated[module_id].append(False)
+                    is_truncated[module_id].append(False)
+                # Increase the per module counter.
+                self.sampled_timesteps_per_module[module_id] += 1
+
+            # Increase counter.
+            B += 1
+        # Increase the counter for environment timesteps.
+        self.sampled_timesteps += batch_size_B
+
+        # Should be convertible to MultiAgentBatch.
+        ret = {
+            **{
+                module_id: {
+                    Columns.OBS: batch(observations[module_id]),
+                    Columns.ACTIONS: batch(actions[module_id]),
+                    Columns.REWARDS: np.array(rewards[module_id]),
+                    Columns.NEXT_OBS: batch(next_observations[module_id]),
+                    Columns.TERMINATEDS: np.array(is_terminated[module_id]),
+                    Columns.TRUNCATEDS: np.array(is_truncated[module_id]),
+                    "weights": np.array(weights[module_id]),
+                    "n_step": np.array(n_steps[module_id]),
+                }
+                for module_id in observations.keys()
+            }
+        }
+
+        # Return multi-agent dictionary.
+        return ret
+
+    def _num_remaining_episodes(self, new_eps, evicted_eps):
+        """Calculates the number of remaining episodes.
+
+        When adding episodes and evicting them in the `add()` method
+        this function calculates iteratively the number of remaining
+        episodes.
+
+        Args:
+            new_eps: List of new episode IDs.
+            evicted_eps: List of evicted episode IDs.
+
+        Returns:
+            Number of episodes remaining after evicting the episodes in
+            `evicted_eps` and adding the episode in `new_eps`.
+        """
+        return len(
+            set(self.episode_id_to_index.keys()).union(set(new_eps)) - set(evicted_eps)
+        )
+
+    def _evict_module_episodes(self, ma_episode: MultiAgentEpisode) -> None:
+        """Evicts the module episodes from the buffer adn updates all counters.
+
+        Args:
+            multi_agent_eps: The multi-agent episode to evict from the buffer.
+        """
+
+        # Note we need to take the agent ids from the evicted episode because
+        # different episodes can have different agents and module mappings.
+        for agent_id in ma_episode.agent_episodes:
+            # Retrieve the corresponding module ID and module episode.
+            module_id = ma_episode._agent_to_module_mapping[agent_id]
+            module_eps = ma_episode.agent_episodes[agent_id]
+            # Update all counters.
+            self._num_module_timesteps[module_id] -= module_eps.env_steps()
+            self._num_module_episodes[module_id] -= 1
+            self._num_module_episodes_evicted[module_id] += 1
+
+    def _update_module_counters(self, ma_episode: MultiAgentEpisode) -> None:
+        """Updates the module counters after adding an episode.
+
+        Args:
+            multi_agent_episode: The multi-agent episode to update the module counters
+                for.
+        """
+        for agent_id in ma_episode.agent_ids:
+            agent_steps = ma_episode.agent_episodes[agent_id].env_steps()
+            # Only add if the agent has stepped in the episode (chunk).
+            if agent_steps > 0:
+                # Receive the corresponding module ID.
+                module_id = ma_episode.module_for(agent_id)
+                self._num_module_timesteps[module_id] += agent_steps
+                self._num_module_timesteps_added[module_id] += agent_steps
+                # if ma_episode.agent_episodes[agent_id].is_done:
+                #     # TODO (simon): Check, if we do not count the same episode
+                #     # multiple times.
+                #     # Also add to the module episode counter.
+                #     self._num_module_episodes[module_id] += 1
+
+    def _add_new_module_indices(
+        self,
+        ma_episode: MultiAgentEpisode,
+        episode_idx: int,
+        ma_episode_exists: bool = True,
+    ) -> None:
+        """Adds the module indices for new episode chunks.
+
+        Args:
+            ma_episode: The multi-agent episode to add the module indices for.
+            episode_idx: The index of the episode in the `self.episodes`.
+            ma_episode_exists: Whether `ma_episode` is already in this buffer (with a
+                predecessor chunk to which we'll concatenate `ma_episode` later).
+        """
+        existing_ma_episode = None
+        if ma_episode_exists:
+            existing_ma_episode = self.episodes[
+                self.episode_id_to_index[ma_episode.id_] - self._num_episodes_evicted
+            ]
+
+        # Note, we iterate through the agent episodes b/c we want to store records
+        # and some agents could not have entered the environment.
+        for agent_id in ma_episode.agent_episodes:
+            # Get the corresponding module id.
+            module_id = ma_episode.module_for(agent_id)
+            # Get the module episode.
+            module_eps = ma_episode.agent_episodes[agent_id]
+
+            # Is the agent episode already in the buffer's existing `ma_episode`?
+            if ma_episode_exists and agent_id in existing_ma_episode.agent_episodes:
+                existing_sa_eps_len = len(existing_ma_episode.agent_episodes[agent_id])
+            # Otherwise, it is a new single-agent episode and we increase the counter.
+            else:
+                existing_sa_eps_len = 0
+                self._num_module_episodes[module_id] += 1
+
+            # Add new module indices.
+            self._module_to_indices[module_id].extend(
+                [
+                    (
+                        # Keep the MAE index for sampling
+                        episode_idx,
+                        agent_id,
+                        existing_sa_eps_len + i,
+                    )
+                    for i in range(len(module_eps))
+                ]
+            )
+
+    def _agents_with_full_transitions(
+        self, observations: Dict[AgentID, ObsType], actions: Dict[AgentID, ActType]
+    ):
+        """Filters for agents that have full transitions.
+
+        Args:
+            observations: The observations of the episode.
+            actions: The actions of the episode.
+
+        Returns:
+            List of agent IDs that have full transitions.
+        """
+        agents_to_sample = []
+        for agent_id in observations[0].keys():
+            # Only if the agent has an action at the first and an observation
+            # at the first and last timestep of the n-step transition, we can sample it.
+            if agent_id in actions and agent_id in observations[-1]:
+                agents_to_sample.append(agent_id)
+        return agents_to_sample

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/replay_buffers/multi_agent_prioritized_episode_buffer.py

@@ -0,0 +1,923 @@
+import copy
+import numpy as np
+import scipy
+
+from collections import defaultdict, deque
+from numpy.typing import NDArray
+from typing import Dict, List, Optional, Set, Tuple, Union
+from ray.rllib.env.multi_agent_episode import MultiAgentEpisode
+from ray.rllib.env.single_agent_episode import SingleAgentEpisode
+from ray.rllib.utils import force_list
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.replay_buffers.multi_agent_episode_buffer import (
+    MultiAgentEpisodeReplayBuffer,
+)
+from ray.rllib.utils.replay_buffers.prioritized_episode_buffer import (
+    PrioritizedEpisodeReplayBuffer,
+)
+from ray.rllib.utils.typing import ModuleID
+from ray.rllib.execution.segment_tree import MinSegmentTree, SumSegmentTree
+
+
+class MultiAgentPrioritizedEpisodeReplayBuffer(
+    MultiAgentEpisodeReplayBuffer, PrioritizedEpisodeReplayBuffer
+):
+    """Multi-agent episode replay buffer that stores episodes by their IDs.
+
+    This class implements a replay buffer as used in "Prioritized Experience
+    Replay" (Schaul et al., 2016) for multi-agent reinforcement learning,
+
+    Each "row" (a slot in a deque) in the buffer is occupied by one episode. If an
+    incomplete episode is added to the buffer and then another chunk of that episode is
+    added at a later time, the buffer will automatically concatenate the new fragment to
+    the original episode. This way, episodes can be completed via subsequent `add`
+    calls.
+
+    Sampling returns a size `B` episode list (number of 'rows'), where each episode
+    holds a tuple tuple of the form
+
+    `(o_t, a_t, sum(r_t+1:t+n), o_t+n)`
+
+    where `o_t` is the observation in `t`, `a_t` the action chosen at observation `o_t`,
+    `o_t+n` is the observation `n` timesteps later and `sum(r_t+1:t+n)` is the sum of
+    all rewards collected over the time steps between `t+1` and `t+n`. The `n`-step can
+    be chosen freely when sampling and defaults to `1`. If `n_step` is a tuple it is
+    sampled uniformly across the interval defined by the tuple (for each row in the
+    batch).
+
+    Each episode contains - in addition to the data tuples presented above - two further
+    elements in its `extra_model_outputs`, namely `n_steps` and `weights`. The former
+    holds the `n_step` used for the sampled timesteps in the episode and the latter the
+    corresponding (importance sampling) weight for the transition.
+
+    After sampling priorities can be updated (for the last sampled episode list) with
+    `self.update_priorities`. This method assigns the new priorities automatically to
+    the last sampled timesteps. Note, this implies that sampling timesteps and updating
+    their corresponding priorities needs to alternate (e.g. sampling several times and
+    then updating the priorities would not work because the buffer caches the last
+    sampled timestep indices).
+
+    .. testcode::
+
+        import gymnasium as gym
+
+        from ray.rllib.env.multi_agent_episode import MultiAgentEpisode
+        from ray.rllib.examples.envs.classes.multi_agent import MultiAgentCartPole
+        from ray.rllib.utils.replay_buffers import (
+            MultiAgentPrioritizedEpisodeReplayBuffer,
+        )
+
+
+        # Create the environment.
+        env = MultiAgentCartPole({"num_agents": 2})
+
+        # Set up the loop variables
+        agent_ids = env.agents
+        agent_ids.append("__all__")
+        terminateds = {aid: False for aid in agent_ids}
+        truncateds = {aid: False for aid in agent_ids}
+        num_timesteps = 10000
+        episodes = []
+
+        # Initialize the first episode entries.
+        eps = MultiAgentEpisode()
+        obs, infos = env.reset()
+        eps.add_env_reset(observations=obs, infos=infos)
+
+        # Sample 10,000 env timesteps.
+        for i in range(num_timesteps):
+            # If terminated we create a new episode.
+            if eps.is_done:
+                episodes.append(eps.finalize())
+                eps = MultiAgentEpisode()
+                terminateds = {aid: False for aid in agent_ids}
+                truncateds = {aid: False for aid in agent_ids}
+                obs, infos = env.reset()
+                eps.add_env_reset(observations=obs, infos=infos)
+
+            # Sample a random action for all agents that should step in the episode
+            # next.
+            actions = {
+                aid: env.get_action_space(aid).sample()
+                for aid in eps.get_agents_to_act()
+            }
+            obs, rewards, terminateds, truncateds, infos = env.step(actions)
+            eps.add_env_step(
+                obs,
+                actions,
+                rewards,
+                infos,
+                terminateds=terminateds,
+                truncateds=truncateds
+            )
+
+        # Add the last (truncated) episode to the list of episodes.
+        if not eps.is_done:
+            episodes.append(eps)
+
+        # Create the buffer.
+        buffer = MultiAgentPrioritizedEpisodeReplayBuffer()
+        # Add the list of episodes sampled.
+        buffer.add(episodes)
+
+        # Pull a sample from the buffer using an `n-step` of 3.
+        sample = buffer.sample(num_items=256, gamma=0.95, n_step=3, beta=0.5)
+    """
+
+    def __init__(
+        self,
+        capacity: int = 10000,
+        *,
+        batch_size_B: int = 16,
+        batch_length_T: int = 1,
+        alpha: float = 1.0,
+        **kwargs,
+    ):
+        """Initializes a `MultiAgentPrioritizedEpisodeReplayBuffer` object
+
+        Args:
+            capacity: The total number of timesteps to be storable in this buffer.
+                Will start ejecting old episodes once this limit is reached.
+            batch_size_B: The number of episodes returned from `sample()`.
+            batch_length_T: The length of each episode in the episode list returned from
+                `sample()`.
+            alpha: The amount of prioritization to be used: `alpha=1.0` means full
+                prioritization, `alpha=0.0` means no prioritization.
+        """
+        # Initialize the parents.
+        MultiAgentEpisodeReplayBuffer.__init__(
+            self,
+            capacity=capacity,
+            batch_size_B=batch_size_B,
+            batch_length_T=batch_length_T,
+            **kwargs,
+        )
+        PrioritizedEpisodeReplayBuffer.__init__(
+            self,
+            capacity=capacity,
+            batch_size_B=batch_size_B,
+            batch_length_T=batch_length_T,
+            alpha=alpha,
+            **kwargs,
+        )
+
+        # TODO (simon): If not needed in synchronized sampling, remove.
+        # Maps indices from samples to their corresponding tree index.
+        self._sample_idx_to_tree_idx = {}
+        # Initialize segment trees for the priority weights per module. Note, b/c
+        # the trees are binary we need for them a capacity that is an exponential
+        # of 2. Double it to enable temporary buffer overflow (we need then free
+        # nodes in the trees).
+        tree_capacity = int(2 ** np.ceil(np.log2(self.capacity)))
+
+        # Each module receives its own segment trees for independent sampling.
+        self._module_to_max_priority: Dict[ModuleID, float] = defaultdict(lambda: 1.0)
+        self._module_to_sum_segment: Dict[ModuleID, "SumSegmentTree"] = defaultdict(
+            lambda: SumSegmentTree(2 * tree_capacity)
+        )
+        self._module_to_min_segment: Dict[ModuleID, "MinSegmentTree"] = defaultdict(
+            lambda: MinSegmentTree(2 * tree_capacity)
+        )
+        # At initialization all nodes are free.
+        self._module_to_free_nodes: Dict[ModuleID, "deque"] = defaultdict(
+            lambda: deque(list(range(2 * tree_capacity)), maxlen=2 * tree_capacity)
+        )
+        # Keep track of the maximum index used from the trees. This helps
+        # to not traverse the complete trees.
+        self._module_to_max_idx: Dict[ModuleID, int] = defaultdict(lambda: 0)
+        # Map from tree indices to sample indices (i.e. `self._indices`).
+        self._module_to_tree_idx_to_sample_idx: Dict[ModuleID, dict] = defaultdict(
+            lambda: {}
+        )
+        # Map from module ID to the last sampled indices to update priorities.
+        self._module_to_last_sampled_indices: Dict[ModuleID, list] = defaultdict(
+            lambda: []
+        )
+
+    @override(MultiAgentEpisodeReplayBuffer)
+    def add(
+        self,
+        episodes: Union[List["MultiAgentEpisode"], "MultiAgentEpisode"],
+        weight: Optional[Union[float, Dict[ModuleID, float]]] = None,
+    ) -> None:
+        """Adds incoming episodes to the replay buffer.
+
+        Note, if the incoming episodes' time steps cause the buffer to overflow,
+        older episodes are evicted. Because episodes usually come in chunks and
+        not complete, this could lead to edge cases (e.g. with very small capacity
+        or very long episode length) where the first part of an episode is evicted
+        while the next part just comes in.
+        To defend against such case, the complete episode is evicted, including
+        the new chunk, unless the episode is the only one in the buffer. In the
+        latter case the buffer will be allowed to overflow in a temporary fashion,
+        i.e. during the next addition of samples to the buffer an attempt is made
+        to fall below capacity again.
+
+        The user is advised to select a large enough buffer with regard to the maximum
+        expected episode length.
+
+        Args:
+            episodes: A list of `SingleAgentEpisode`s that contain the episode data.
+            weight: A starting priority for the time steps in `episodes`. If `None`
+                the maximum priority is used, i.e. 1.0 (as suggested in the original
+                paper we scale weights to the interval [0.0, 1.0]). If a dictionary
+                is provided, it must contain the weights for each module.
+
+        """
+        # Define the weights.
+        weight_per_module = {}
+        # If no weight is provided, use the maximum priority.
+        if weight is None:
+            weight = self._max_priority
+        # If `weight` is a dictionary, use the module weights.
+        elif isinstance(dict, weight):
+            weight_per_module = weight
+            # Define the weight as the mean of the module weights.
+            weight = np.mean(list(weight.values()))
+
+        episodes: List["MultiAgentEpisode"] = force_list(episodes)
+
+        new_episode_ids: List[str] = [eps.id_ for eps in episodes]
+        # Calculate the total number of environment timesteps in the new episodes.
+        # Note, we need the potential new sum of timesteps to decide whether to
+        # evict episodes.
+        total_env_timesteps = sum([eps.env_steps() for eps in episodes])
+        self._num_timesteps += total_env_timesteps
+        self._num_timesteps_added += total_env_timesteps
+
+        # Evict old episodes.
+        eps_evicted_ids: Set[Union[str, int]] = set()
+        eps_evicted_idxs: Set[int] = set()
+        # Only evict episodes if the buffer is full and there is more than one
+
+        while (
+            self._num_timesteps > self.capacity
+            and self._num_remaining_episodes(new_episode_ids, eps_evicted_ids) != 1
+        ):
+            # Evict episode.
+            evicted_episode = self.episodes.popleft()
+            eps_evicted_ids.add(evicted_episode.id_)
+            eps_evicted_idxs.add(self.episode_id_to_index.pop(evicted_episode.id_))
+            # If this episode has a new chunk in the new episodes added,
+            # we subtract it again.
+            # TODO (sven, simon): Should we just treat such an episode chunk
+            # as a new episode?
+            if evicted_episode.id_ in new_episode_ids:
+                idx = next(
+                    i
+                    for i, eps in enumerate(episodes)
+                    if eps.id_ == evicted_episode.id_
+                )
+                new_eps_to_evict = episodes.pop(idx)
+                # Remove the timesteps of the evicted new episode from the counter.
+                self._num_timesteps -= new_eps_to_evict.env_steps()
+                self._num_timesteps_added -= new_eps_to_evict.env_steps()
+            # Remove the timesteps of the evicted old episode from the counter.
+            self._num_timesteps -= evicted_episode.env_steps()
+            self._num_agent_timesteps -= evicted_episode.agent_steps()
+            self._num_episodes_evicted += 1
+            # Remove the module timesteps of the evicted episode from the counters.
+            self._evict_module_episodes(evicted_episode)
+            del evicted_episode
+
+        # Add agent and module steps.
+        for eps in episodes:
+            self._num_agent_timesteps += eps.agent_steps()
+            self._num_agent_timesteps_added += eps.agent_steps()
+            # Update the module counters by the module timesteps.
+            self._update_module_counters(eps)
+
+        # Remove corresponding indices, if episodes were evicted.
+        if eps_evicted_idxs:
+            new_indices = []
+            # Each index 2-tuple is of the form (ma_episode_idx, timestep) and
+            # refers to a certain environment timestep in a certain multi-agent
+            # episode.
+            i = 0
+            for idx_tuple in self._indices:
+                # If episode index is from an evicted episode, remove it from the
+                # indices and clean up.
+                if idx_tuple[0] in eps_evicted_idxs:
+                    # Here we need the index of a multi-agent sample in the segment
+                    # tree.
+                    self._free_nodes.appendleft(idx_tuple[2])
+                    # Remove also the potentially maximum index.
+                    self._max_idx -= 1 if self._max_idx == idx_tuple[2] else 0
+                    # Reset to defaults.
+                    self._sum_segment[idx_tuple[2]] = 0.0
+                    self._min_segment[idx_tuple[2]] = float("inf")
+                    sample_idx = self._tree_idx_to_sample_idx[idx_tuple[2]]
+                    self._tree_idx_to_sample_idx.pop(idx_tuple[2])
+                    self._sample_idx_to_tree_idx.pop(sample_idx)
+                # Otherwise, keep the index.
+                else:
+                    new_indices.append(idx_tuple)
+                    self._tree_idx_to_sample_idx[idx_tuple[2]] = i
+                    self._sample_idx_to_tree_idx[i] = idx_tuple[2]
+                    i += 1
+            # Assign the new list of indices.
+            self._indices = new_indices
+            # Also remove corresponding module indices.
+            for module_id, module_indices in self._module_to_indices.items():
+                new_module_indices = []
+                # Each index 4-tuple is of the form
+                # (ma_episode_idx, agent_id, timestep, segtree_idx) and refers to a
+                # certain agent timestep in a certain multi-agent episode.
+                i = 0
+                for idx_quadlet in module_indices:
+                    # If episode index is from an evicted episode, remove it from the
+                    # indices and clean up.
+                    if idx_quadlet[0] in eps_evicted_idxs:
+                        # Here we need the index of a multi-agent sample in the segment
+                        # tree.
+                        self._module_to_free_nodes[module_id].appendleft(idx_quadlet[3])
+                        # Remove also the potentially maximum index per module.
+                        self._module_to_max_idx[module_id] -= (
+                            1
+                            if self._module_to_max_idx[module_id] == idx_quadlet[3]
+                            else 0
+                        )
+                        # Set to defaults.
+                        self._module_to_sum_segment[module_id][idx_quadlet[3]] = 0.0
+                        self._module_to_min_segment[module_id][idx_quadlet[3]] = float(
+                            "inf"
+                        )
+                        self._module_to_tree_idx_to_sample_idx[module_id].pop(
+                            idx_quadlet[3]
+                        )
+                    # Otherwise, keep the index.
+                    else:
+                        new_module_indices.append(idx_quadlet)
+                        self._module_to_tree_idx_to_sample_idx[module_id][
+                            idx_quadlet[3]
+                        ] = i
+                        i += 1
+                # Assign the new list of indices for the module.
+                self._module_to_indices[module_id] = new_module_indices
+
+        j = len(self._indices)
+        for eps in episodes:
+            eps = copy.deepcopy(eps)
+            # If the episode is part of an already existing episode, concatenate.
+            if eps.id_ in self.episode_id_to_index:
+                eps_idx = self.episode_id_to_index[eps.id_]
+                existing_eps = self.episodes[eps_idx - self._num_episodes_evicted]
+                existing_len = len(existing_eps)
+                self._indices.extend(
+                    [
+                        (
+                            eps_idx,
+                            existing_len + i,
+                            # Get the index in the segment trees.
+                            self._get_free_node_and_assign(j + i, weight),
+                        )
+                        for i in range(len(eps))
+                    ]
+                )
+                # Add new module indices.
+                self._add_new_module_indices(eps, eps_idx, True, weight_per_module)
+                # Concatenate the episode chunk.
+                existing_eps.concat_episode(eps)
+            # Otherwise, create a new entry.
+            else:
+                # New episode.
+                self.episodes.append(eps)
+                eps_idx = len(self.episodes) - 1 + self._num_episodes_evicted
+                self.episode_id_to_index[eps.id_] = eps_idx
+                self._indices.extend(
+                    [
+                        (eps_idx, i, self._get_free_node_and_assign(j + i, weight))
+                        for i in range(len(eps))
+                    ]
+                )
+                # Add new module indices.
+                self._add_new_module_indices(eps, eps_idx, False, weight_per_module)
+            # Increase index to the new length of `self._indices`.
+            j = len(self._indices)
+
+    @override(MultiAgentEpisodeReplayBuffer)
+    def sample(
+        self,
+        num_items: Optional[int] = None,
+        *,
+        batch_size_B: Optional[int] = None,
+        batch_length_T: Optional[int] = None,
+        n_step: Optional[Union[int, Tuple]] = 1,
+        gamma: float = 0.99,
+        include_infos: bool = False,
+        include_extra_model_outputs: bool = False,
+        replay_mode: str = "independent",
+        modules_to_sample: Optional[List[ModuleID]] = None,
+        beta: float = 0.0,
+        **kwargs,
+    ) -> Union[List["MultiAgentEpisode"], List["SingleAgentEpisode"]]:
+        """Samples a list of episodes with multi-agent transitions.
+
+        This sampling method also adds (importance sampling) weights to the returned
+        batch. See for prioritized sampling Schaul et al. (2016).
+
+        Multi-agent transitions can be sampled either `"independent"` or
+        `"synchronized"` with the former sampling for each module independent agent
+        steps and the latter sampling agent transitions from the same environment step.
+
+        The n-step parameter can be either a single integer or a tuple of two integers.
+        In the former case, the n-step is fixed to the given integer and in the latter
+        case, the n-step is sampled uniformly from the given range. Large n-steps could
+        potentially lead to many retries because not all samples might have a full
+        n-step transition.
+
+        Sampling returns episode lists of size B (number of 'rows'), where each episode
+        holds a transition of the form
+
+        `(o_t, a_t, sum(r_t+1:t+n), o_t+n, terminated_t+n, truncated_t+n)`
+
+        where `o_t` is the observation in `t`, `a_t` the action chosen at observation
+        `o_t`, `o_t+n` is the observation `n` timesteps later and `sum(r_t+1:t+n)` is
+        the sum of all rewards collected over the time steps between `t+1` and `t+n`.
+        The `n`-step can be chosen freely when sampling and defaults to `1`. If `n_step`
+        is a tuple it is sampled uniformly across the interval defined by the tuple (for
+        each row in the batch), i.e. from the interval `[n_step[0], n_step[1]]`.
+
+        If requested, `info`s of a transition's first and  last timestep `t+n` and/or
+        `extra_model_outputs` from the first timestep (e.g. log-probabilities, etc.) are
+        added to the batch.
+
+        Each episode contains - in addition to the data tuples presented above - two
+        further entries in its `extra_model_outputs`, namely `n_steps` and `weigths`.
+        The former holds the `n_step` used for each transition and the latter the
+        (importance sampling) weight of `1.0` for each row in the batch. This weight
+        is used for weighted loss calculations in the training process.
+
+        Args:
+            num_items: The number of items to sample. If provided, `batch_size_B`
+                should be `None`.
+            batch_size_B: The batch size to sample. If provided, `num_items`
+                should be `None`.
+            batch_length_T: The length of the sampled batch. If not provided, the
+                default batch length is used. This feature is not yet implemented.
+            n_step: The n-step to sample. If the n-step is a tuple, the n-step is
+                sampled uniformly from the given range. If not provided, the default
+                n-step of `1` is used.
+            gamma: The discount factor for the n-step reward calculation.
+            include_infos: Whether to include the infos in the sampled episodes.
+            include_extra_model_outputs: Whether to include the extra model outputs
+                in the sampled episodes.
+            replay_mode: The replay mode to use for sampling. Either `"independent"`
+                or `"synchronized"`.
+            modules_to_sample: A list of module IDs to sample from. If not provided,
+                transitions for aall modules are sampled.
+            beta: The exponent of the importance sampling weight (see Schaul et
+                al. (2016)). A `beta=0.0` does not correct for the bias introduced
+                by prioritized replay and `beta=1.0` fully corrects for it.
+
+        Returns:
+            A list of 1-step long single-agent episodes containing all basic episode
+            data and if requested infos and extra model outputs. In addition extra model
+            outputs hold the (importance sampling) weights and the n-step used for each
+            transition.
+        """
+        assert beta >= 0.0
+
+        if num_items is not None:
+            assert batch_size_B is None, (
+                "Cannot call `sample()` with both `num_items` and `batch_size_B` "
+                "provided! Use either one."
+            )
+            batch_size_B = num_items
+
+        # Use our default values if no sizes/lengths provided.
+        batch_size_B = batch_size_B or self.batch_size_B
+        # TODO (simon): Implement trajectory sampling for RNNs.
+        batch_length_T = batch_length_T or self.batch_length_T
+
+        # Sample for each module independently.
+        if replay_mode == "independent":
+            return self._sample_independent(
+                batch_size_B=batch_size_B,
+                batch_length_T=batch_length_T,
+                n_step=n_step,
+                gamma=gamma,
+                include_infos=include_infos,
+                include_extra_model_outputs=include_extra_model_outputs,
+                modules_to_sample=modules_to_sample,
+                beta=beta,
+            )
+        # Otherwise, sample synchronized.
+        else:
+            return self._sample_synchonized(
+                batch_size_B=batch_size_B,
+                batch_length_T=batch_length_T,
+                n_step=n_step,
+                gamma=gamma,
+                include_infos=include_infos,
+                include_extra_model_outputs=include_extra_model_outputs,
+                modules_to_sample=modules_to_sample,
+            )
+
+    @override(PrioritizedEpisodeReplayBuffer)
+    def update_priorities(
+        self,
+        priorities: Union[NDArray, Dict[ModuleID, NDArray]],
+        module_id: ModuleID,
+    ) -> None:
+        """Update the priorities of items at corresponding indices.
+
+        Usually, incoming priorities are TD-errors.
+
+        Args:
+            priorities: Numpy array containing the new priorities to be used
+                in sampling for the items in the last sampled batch.
+        """
+
+        assert len(priorities) == len(self._module_to_last_sampled_indices[module_id])
+
+        for idx, priority in zip(
+            self._module_to_last_sampled_indices[module_id], priorities
+        ):
+            # sample_idx = self._module_to_tree_idx_to_sample_idx[module_id][idx]
+            # ma_episode_idx = (
+            #     self._module_to_indices[module_id][sample_idx][0]
+            #     - self._num_episodes_evicted
+            # )
+
+            # ma_episode_indices.append(ma_episode_idx)
+            # Note, TD-errors come in as absolute values or results from
+            # cross-entropy loss calculations.
+            # assert priority > 0, f"priority was {priority}"
+            priority = max(priority, 1e-12)
+            assert 0 <= idx < self._module_to_sum_segment[module_id].capacity
+            # TODO (simon): Create metrics.
+            # delta = priority**self._alpha - self._sum_segment[idx]
+            # Update the priorities in the segment trees.
+            self._module_to_sum_segment[module_id][idx] = priority**self._alpha
+            self._module_to_min_segment[module_id][idx] = priority**self._alpha
+            # Update the maximal priority.
+            self._module_to_max_priority[module_id] = max(
+                self._module_to_max_priority[module_id], priority
+            )
+        # Clear the corresponding index list for the module.
+        self._module_to_last_sampled_indices[module_id].clear()
+
+        # TODO (simon): Use this later for synchronized sampling.
+        # for ma_episode_idx in ma_episode_indices:
+        #     ma_episode_tree_idx = self._sample_idx_to_tree_idx(ma_episode_idx)
+        #     ma_episode_idx =
+
+        #     # Update the weights
+        # self._sum_segment[tree_idx] = sum(
+        #     self._module_to_sum_segment[module_id][idx]
+        #     for module_id, idx in self._tree_idx_to_sample_idx[tree_idx]
+        # )
+        # self._min_segment[tree_idx] = min(
+        #     self._module_to_min_segment[module_id][idx]
+        #     for module_id, idx in self._tree_idx_to_sample_idx[tree_idx]
+        # )
+
+    @override(MultiAgentEpisodeReplayBuffer)
+    def get_state(self):
+        return (
+            MultiAgentEpisodeReplayBuffer.get_state(self)
+            | PrioritizedEpisodeReplayBuffer.get_state(self)
+            | {
+                "_module_to_max_priority": list(self._module_to_max_priority.items()),
+                "_module_to_sum_segment": list(self._module_to_sum_segment.items()),
+                "_module_to_min_segment": list(self._module_to_min_segment.items()),
+                "_module_to_free_nodes": list(self._module_to_free_nodes.items()),
+                "_module_to_max_idx": list(self._module_to_max_idx.items()),
+                "_module_to_tree_idx_to_sample_idx": list(
+                    self._module_to_tree_idx_to_sample_idx.items()
+                ),
+                "_module_to_last_sampled_indices": list(
+                    self._module_to_last_sampled_indices.items()
+                ),
+            }
+        )
+
+    @override(MultiAgentEpisodeReplayBuffer)
+    def set_state(self, state) -> None:
+        MultiAgentEpisodeReplayBuffer.set_state(self, state)
+        PrioritizedEpisodeReplayBuffer.set_state(self, state)
+        self._module_to_max_priority = defaultdict(
+            lambda: 1.0, dict(state["_module_to_max_priority"])
+        )
+        tree_capacity = int(2 ** np.ceil(np.log2(self.capacity)))
+        self._module_to_sum_segment = defaultdict(
+            lambda: SumSegmentTree(2 * tree_capacity),
+            dict(state["_module_to_sum_segment"]),
+        )
+        self._module_to_min_segment = defaultdict(
+            lambda: SumSegmentTree(2 * tree_capacity),
+            dict(state["_module_to_min_segment"]),
+        )
+        self._module_to_free_nodes = defaultdict(
+            lambda: deque(list(range(2 * tree_capacity)), maxlen=2 * tree_capacity),
+            dict(state["_module_to_free_nodes"]),
+        )
+        self._module_to_max_idx = defaultdict(
+            lambda: 0, dict(state["_module_to_max_idx"])
+        )
+        self._module_to_tree_idx_to_sample_idx = defaultdict(
+            lambda: {}, dict(state["_module_to_tree_idx_to_sample_idx"])
+        )
+        self._module_to_last_sampled_indices = defaultdict(
+            lambda: [], dict(state["_module_to_last_sampled_indices"])
+        )
+
+    @override(MultiAgentEpisodeReplayBuffer)
+    def _add_new_module_indices(
+        self,
+        ma_episode: MultiAgentEpisode,
+        ma_episode_idx: int,
+        ma_episode_exists: bool = True,
+        weight: Optional[Union[float, Dict[ModuleID, float]]] = None,
+    ) -> None:
+        """Adds the module indices for new episode chunks.
+
+        Args:
+            multi_agent_episode: The multi-agent episode to add the module indices for.
+            episode_idx: The index of the episode in the `self.episodes`.
+        """
+        existing_ma_episode = None
+        if ma_episode_exists:
+            existing_ma_episode = self.episodes[
+                self.episode_id_to_index[ma_episode.id_] - self._num_episodes_evicted
+            ]
+
+        for agent_id in ma_episode.agent_ids:
+            # Get the corresponding module id.
+            module_id = ma_episode.module_for(agent_id)
+            # Get the module episode.
+            module_eps = ma_episode.agent_episodes[agent_id]
+
+            # Is the agent episode already in the buffer's existing `ma_episode`?
+            if ma_episode_exists and agent_id in existing_ma_episode.agent_episodes:
+                existing_sa_eps_len = len(existing_ma_episode.agent_episodes[agent_id])
+            # Otherwise, it is a new single-agent episode and we increase the counter.
+            else:
+                existing_sa_eps_len = 0
+                self._num_module_episodes[module_id] += 1
+
+            # Add new module indices.
+            module_weight = weight.get(
+                module_id, self._module_to_max_priority[module_id]
+            )
+            j = len(self._module_to_indices[module_id])
+            self._module_to_indices[module_id].extend(
+                [
+                    (
+                        # Keep the MAE index for sampling.
+                        ma_episode_idx,
+                        agent_id,
+                        existing_sa_eps_len + i,
+                        # Get the index in the segment trees.
+                        self._get_free_node_per_module_and_assign(
+                            module_id,
+                            j + i,
+                            module_weight,
+                        ),
+                    )
+                    for i in range(len(module_eps))
+                ]
+            )
+
+    @override(PrioritizedEpisodeReplayBuffer)
+    def _get_free_node_and_assign(self, sample_index, weight: float = 1.0) -> int:
+        """Gets the next free node in the segment trees.
+
+        In addition the initial priorities for a new transition are added
+        to the segment trees and the index of the nodes is added to the
+        index mapping.
+
+        Args:
+            sample_index: The index of the sample in the `self._indices` list.
+            weight: The initial priority weight to be used in sampling for
+                the item at index `sample_index`.
+
+        Returns:
+            The index in the segment trees `self._sum_segment` and
+            `self._min_segment` for the item at index `sample_index` in
+            ``self._indices`.
+        """
+        # Get an index from the free nodes in the segment trees.
+        idx = self._free_nodes.popleft()
+        self._max_idx = idx if idx > self._max_idx else self._max_idx
+        # Add the weight to the segments.
+        self._sum_segment[idx] = weight**self._alpha
+        self._min_segment[idx] = weight**self._alpha
+        # Map the index in the trees to the index in `self._indices`.
+        self._tree_idx_to_sample_idx[idx] = sample_index
+        self._sample_idx_to_tree_idx[sample_index] = idx
+        # Return the index.
+        return idx
+
+    def _get_free_node_per_module_and_assign(
+        self, module_id: ModuleID, sample_index, weight: float = 1.0
+    ) -> int:
+        """Gets the next free node in the segment trees.
+
+        In addition the initial priorities for a new transition are added
+        to the segment trees and the index of the nodes is added to the
+        index mapping.
+
+        Args:
+            sample_index: The index of the sample in the `self._indices` list.
+            weight: The initial priority weight to be used in sampling for
+                the item at index `sample_index`.
+
+        Returns:
+            The index in the segment trees `self._sum_segment` and
+            `self._min_segment` for the item at index `sample_index` in
+            ``self._indices`.
+        """
+        # Get an index from the free nodes in the segment trees.
+        idx = self._module_to_free_nodes[module_id].popleft()
+        self._module_to_max_idx[module_id] = (
+            idx
+            if idx > self._module_to_max_idx[module_id]
+            else self._module_to_max_idx[module_id]
+        )
+        # Add the weight to the segments.
+        # TODO (simon): Allow alpha to be chosen per module.
+        self._module_to_sum_segment[module_id][idx] = weight**self._alpha
+        self._module_to_min_segment[module_id][idx] = weight**self._alpha
+        # Map the index in the trees to the index in `self._indices`.
+        self._module_to_tree_idx_to_sample_idx[module_id][idx] = sample_index
+        # Return the index.
+        return idx
+
+    @override(MultiAgentEpisodeReplayBuffer)
+    def _sample_independent(
+        self,
+        batch_size_B: Optional[int],
+        batch_length_T: Optional[int],
+        n_step: Optional[Union[int, Tuple]],
+        gamma: float,
+        include_infos: bool,
+        include_extra_model_outputs: bool,
+        modules_to_sample: Optional[List[ModuleID]],
+        beta: Optional[float],
+    ) -> List["SingleAgentEpisode"]:
+        """Samples a single-agent episode list with independent transitions.
+
+        Note, independent sampling means that each module samples its transitions
+        independently from the replay buffer. This is the default sampling mode.
+        In contrast, synchronized sampling samples transitions from the same
+        environment step.
+        """
+
+        actual_n_step = n_step or 1
+        # Sample the n-step if necessary.
+        random_n_step = isinstance(n_step, tuple)
+
+        # Keep track of the indices that were sampled last for updating the
+        # weights later (see `ray.rllib.utils.replay_buffer.utils.
+        # update_priorities_in_episode_replay_buffer`).
+        # self._last_sampled_indices = defaultdict(lambda: [])
+
+        sampled_episodes = []
+        # TODO (simon): Ensure that the module has data and if not, skip it.
+        # TODO (sven): Should we then error out or skip? I think the Learner
+        # should handle this case when a module has no train data.
+        modules_to_sample = modules_to_sample or set(self._module_to_indices.keys())
+        for module_id in modules_to_sample:
+            # Sample proportionally from the replay buffer's module segments using the
+            # respective weights.
+            module_total_segment_sum = self._module_to_sum_segment[module_id].sum()
+            module_p_min = (
+                self._module_to_min_segment[module_id].min() / module_total_segment_sum
+            )
+            # TODO (simon): Allow individual betas per module.
+            module_max_weight = (module_p_min * self.get_num_timesteps(module_id)) ** (
+                -beta
+            )
+            B = 0
+            while B < batch_size_B:
+                # First, draw a random sample from Uniform(0, sum over all weights).
+                # Note, transitions with higher weight get sampled more often (as
+                # more random draws fall into larger intervals).
+                module_random_sum = (
+                    self.rng.random() * self._module_to_sum_segment[module_id].sum()
+                )
+                # Get the highest index in the sum-tree for which the sum is
+                # smaller or equal the random sum sample.
+                # Note, in contrast to Schaul et al. (2018) (who sample
+                # `o_(t + n_step)`, Algorithm 1) we sample `o_t`.
+                module_idx = self._module_to_sum_segment[module_id].find_prefixsum_idx(
+                    module_random_sum
+                )
+                # Get the theoretical probability mass for drawing this sample.
+                module_p_sample = (
+                    self._module_to_sum_segment[module_id][module_idx]
+                    / module_total_segment_sum
+                )
+                # Compute the importance sampling weight.
+                module_weight = (
+                    module_p_sample * self.get_num_timesteps(module_id)
+                ) ** (-beta)
+                # Now, get the transition stored at this index.
+                index_quadlet = self._module_to_indices[module_id][
+                    self._module_to_tree_idx_to_sample_idx[module_id][module_idx]
+                ]
+
+                # This will be an agent timestep (not env timestep).
+                # TODO (simon, sven): Maybe deprecate sa_episode_idx (_) in the index
+                #   quads. Is there any need for it?
+                ma_episode_idx, agent_id, sa_episode_ts = (
+                    index_quadlet[0] - self._num_episodes_evicted,
+                    index_quadlet[1],
+                    index_quadlet[2],
+                )
+
+                # Get the multi-agent episode.
+                ma_episode = self.episodes[ma_episode_idx]
+                # Retrieve the single-agent episode for filtering.
+                sa_episode = ma_episode.agent_episodes[agent_id]
+
+                # If we use random n-step sampling, draw the n-step for this item.
+                if random_n_step:
+                    actual_n_step = int(self.rng.integers(n_step[0], n_step[1]))
+                # If we cannnot make the n-step, we resample.
+                if sa_episode_ts + actual_n_step > len(sa_episode):
+                    continue
+                # Note, this will be the reward after executing action
+                # `a_(episode_ts)`. For `n_step>1` this will be the discounted sum
+                # of all rewards that were collected over the last n steps.
+                sa_raw_rewards = sa_episode.get_rewards(
+                    slice(sa_episode_ts, sa_episode_ts + actual_n_step)
+                )
+                sa_rewards = scipy.signal.lfilter(
+                    [1], [1, -gamma], sa_raw_rewards[::-1], axis=0
+                )[-1]
+
+                sampled_sa_episode = SingleAgentEpisode(
+                    id_=sa_episode.id_,
+                    # Provide the IDs for the learner connector.
+                    agent_id=sa_episode.agent_id,
+                    module_id=sa_episode.module_id,
+                    multi_agent_episode_id=ma_episode.id_,
+                    # Ensure that each episode contains a tuple of the form:
+                    #   (o_t, a_t, sum(r_(t:t+n_step)), o_(t+n_step))
+                    # Two observations (t and t+n).
+                    observations=[
+                        sa_episode.get_observations(sa_episode_ts),
+                        sa_episode.get_observations(sa_episode_ts + actual_n_step),
+                    ],
+                    observation_space=sa_episode.observation_space,
+                    infos=(
+                        [
+                            sa_episode.get_infos(sa_episode_ts),
+                            sa_episode.get_infos(sa_episode_ts + actual_n_step),
+                        ]
+                        if include_infos
+                        else None
+                    ),
+                    actions=[sa_episode.get_actions(sa_episode_ts)],
+                    action_space=sa_episode.action_space,
+                    rewards=[sa_rewards],
+                    # If the sampled single-agent episode is the single-agent episode's
+                    # last time step, check, if the single-agent episode is terminated
+                    # or truncated.
+                    terminated=(
+                        sa_episode_ts + actual_n_step >= len(sa_episode)
+                        and sa_episode.is_terminated
+                    ),
+                    truncated=(
+                        sa_episode_ts + actual_n_step >= len(sa_episode)
+                        and sa_episode.is_truncated
+                    ),
+                    extra_model_outputs={
+                        "weights": [
+                            module_weight / module_max_weight * 1
+                        ],  # actual_size=1
+                        "n_step": [actual_n_step],
+                        **(
+                            {
+                                k: [
+                                    sa_episode.get_extra_model_outputs(k, sa_episode_ts)
+                                ]
+                                for k in sa_episode.extra_model_outputs.keys()
+                            }
+                            if include_extra_model_outputs
+                            else {}
+                        ),
+                    },
+                    # TODO (sven): Support lookback buffers.
+                    len_lookback_buffer=0,
+                    t_started=sa_episode_ts,
+                )
+                # Append single-agent episode to the list of sampled episodes.
+                sampled_episodes.append(sampled_sa_episode)
+
+                # Increase counter.
+                B += 1
+                # Keep track of sampled indices for updating priorities later for each
+                # module.
+                self._module_to_last_sampled_indices[module_id].append(module_idx)
+
+            # Increase the per module timesteps counter.
+            self.sampled_timesteps_per_module[module_id] += B
+
+        # Increase the counter for environment timesteps.
+        self.sampled_timesteps += batch_size_B
+        # Return multi-agent dictionary.
+        return sampled_episodes

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/replay_buffers/multi_agent_replay_buffer.py

@@ -0,0 +1,392 @@
+import collections
+import logging
+from enum import Enum
+from typing import Any, Dict, Optional
+
+from ray.util.timer import _Timer
+from ray.rllib.policy.rnn_sequencing import timeslice_along_seq_lens_with_overlap
+from ray.rllib.policy.sample_batch import MultiAgentBatch, SampleBatch
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.deprecation import Deprecated
+from ray.rllib.utils.from_config import from_config
+from ray.rllib.utils.replay_buffers.replay_buffer import (
+    _ALL_POLICIES,
+    ReplayBuffer,
+    StorageUnit,
+)
+from ray.rllib.utils.typing import PolicyID, SampleBatchType
+from ray.util.annotations import DeveloperAPI
+from ray.util.debug import log_once
+
+logger = logging.getLogger(__name__)
+
+
+@DeveloperAPI
+class ReplayMode(Enum):
+    LOCKSTEP = "lockstep"
+    INDEPENDENT = "independent"
+
+
+@DeveloperAPI
+def merge_dicts_with_warning(args_on_init, args_on_call):
+    """Merge argument dicts, overwriting args_on_call with warning.
+
+    The MultiAgentReplayBuffer supports setting standard arguments for calls
+    of methods of the underlying buffers. These arguments can be
+    overwritten. Such overwrites trigger a warning to the user.
+    """
+    for arg_name, arg_value in args_on_call.items():
+        if arg_name in args_on_init:
+            if log_once("overwrite_argument_{}".format((str(arg_name)))):
+                logger.warning(
+                    "Replay Buffer was initialized to have "
+                    "underlying buffers methods called with "
+                    "argument `{}={}`, but was subsequently called "
+                    "with `{}={}`.".format(
+                        arg_name,
+                        args_on_init[arg_name],
+                        arg_name,
+                        arg_value,
+                    )
+                )
+    return {**args_on_init, **args_on_call}
+
+
+@DeveloperAPI
+class MultiAgentReplayBuffer(ReplayBuffer):
+    """A replay buffer shard for multiagent setups.
+
+    This buffer is meant to be run in parallel to distribute experiences
+    across `num_shards` shards. Unlike simpler buffers, it holds a set of
+    buffers - one for each policy ID.
+    """
+
+    def __init__(
+        self,
+        capacity: int = 10000,
+        storage_unit: str = "timesteps",
+        num_shards: int = 1,
+        replay_mode: str = "independent",
+        replay_sequence_override: bool = True,
+        replay_sequence_length: int = 1,
+        replay_burn_in: int = 0,
+        replay_zero_init_states: bool = True,
+        underlying_buffer_config: dict = None,
+        **kwargs
+    ):
+        """Initializes a MultiAgentReplayBuffer instance.
+
+        Args:
+            capacity: The capacity of the buffer, measured in `storage_unit`.
+            storage_unit: Either 'timesteps', 'sequences' or
+                'episodes'. Specifies how experiences are stored. If they
+                are stored in episodes, replay_sequence_length is ignored.
+            num_shards: The number of buffer shards that exist in total
+                (including this one).
+            replay_mode: One of "independent" or "lockstep". Determines,
+                whether batches are sampled independently or to an equal
+                amount.
+            replay_sequence_override: If True, ignore sequences found in incoming
+                batches, slicing them into sequences as specified by
+                `replay_sequence_length` and `replay_sequence_burn_in`. This only has
+                an effect if storage_unit is `sequences`.
+            replay_sequence_length: The sequence length (T) of a single
+                sample. If > 1, we will sample B x T from this buffer. This
+                only has an effect if storage_unit is 'timesteps'.
+            replay_burn_in: This is the number of timesteps
+                each sequence overlaps with the previous one to generate a
+                better internal state (=state after the burn-in), instead of
+                starting from 0.0 each RNN rollout. This only has an effect
+                if storage_unit is `sequences`.
+            replay_zero_init_states: Whether the initial states in the
+                buffer (if replay_sequence_length > 0) are alwayas 0.0 or
+                should be updated with the previous train_batch state outputs.
+            underlying_buffer_config: A config that contains all necessary
+                constructor arguments and arguments for methods to call on
+                the underlying buffers.
+            ``**kwargs``: Forward compatibility kwargs.
+        """
+        shard_capacity = capacity // num_shards
+        ReplayBuffer.__init__(self, capacity, storage_unit)
+
+        # If the user provides an underlying buffer config, we use to
+        # instantiate and interact with underlying buffers
+        self.underlying_buffer_config = underlying_buffer_config
+        if self.underlying_buffer_config is not None:
+            self.underlying_buffer_call_args = self.underlying_buffer_config
+        else:
+            self.underlying_buffer_call_args = {}
+        self.replay_sequence_override = replay_sequence_override
+        self.replay_mode = replay_mode
+        self.replay_sequence_length = replay_sequence_length
+        self.replay_burn_in = replay_burn_in
+        self.replay_zero_init_states = replay_zero_init_states
+        self.replay_sequence_override = replay_sequence_override
+
+        if (
+            replay_sequence_length > 1
+            and self.storage_unit is not StorageUnit.SEQUENCES
+        ):
+            logger.warning(
+                "MultiAgentReplayBuffer configured with "
+                "`replay_sequence_length={}`, but `storage_unit={}`. "
+                "replay_sequence_length will be ignored and set to 1.".format(
+                    replay_sequence_length, storage_unit
+                )
+            )
+            self.replay_sequence_length = 1
+
+        if replay_sequence_length == 1 and self.storage_unit is StorageUnit.SEQUENCES:
+            logger.warning(
+                "MultiAgentReplayBuffer configured with "
+                "`replay_sequence_length={}`, but `storage_unit={}`. "
+                "This will result in sequences equal to timesteps.".format(
+                    replay_sequence_length, storage_unit
+                )
+            )
+
+        if replay_mode in ["lockstep", ReplayMode.LOCKSTEP]:
+            self.replay_mode = ReplayMode.LOCKSTEP
+            if self.storage_unit in [StorageUnit.EPISODES, StorageUnit.SEQUENCES]:
+                raise ValueError(
+                    "MultiAgentReplayBuffer does not support "
+                    "lockstep mode with storage unit `episodes`"
+                    "or `sequences`."
+                )
+        elif replay_mode in ["independent", ReplayMode.INDEPENDENT]:
+            self.replay_mode = ReplayMode.INDEPENDENT
+        else:
+            raise ValueError("Unsupported replay mode: {}".format(replay_mode))
+
+        if self.underlying_buffer_config:
+            ctor_args = {
+                **{"capacity": shard_capacity, "storage_unit": StorageUnit.FRAGMENTS},
+                **self.underlying_buffer_config,
+            }
+
+            def new_buffer():
+                return from_config(self.underlying_buffer_config["type"], ctor_args)
+
+        else:
+            # Default case
+            def new_buffer():
+                self.underlying_buffer_call_args = {}
+                return ReplayBuffer(
+                    self.capacity,
+                    storage_unit=StorageUnit.FRAGMENTS,
+                )
+
+        self.replay_buffers = collections.defaultdict(new_buffer)
+
+        # Metrics.
+        self.add_batch_timer = _Timer()
+        self.replay_timer = _Timer()
+        self._num_added = 0
+
+    def __len__(self) -> int:
+        """Returns the number of items currently stored in this buffer."""
+        return sum(len(buffer._storage) for buffer in self.replay_buffers.values())
+
+    @DeveloperAPI
+    @Deprecated(
+        old="ReplayBuffer.replay()",
+        new="ReplayBuffer.sample(num_items)",
+        error=True,
+    )
+    def replay(self, num_items: int = None, **kwargs) -> Optional[SampleBatchType]:
+        """Deprecated in favor of new ReplayBuffer API."""
+        pass
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def add(self, batch: SampleBatchType, **kwargs) -> None:
+        """Adds a batch to the appropriate policy's replay buffer.
+
+        Turns the batch into a MultiAgentBatch of the DEFAULT_POLICY_ID if
+        it is not a MultiAgentBatch. Subsequently, adds the individual policy
+        batches to the storage.
+
+        Args:
+            batch : The batch to be added.
+            ``**kwargs``: Forward compatibility kwargs.
+        """
+        if batch is None:
+            if log_once("empty_batch_added_to_buffer"):
+                logger.info(
+                    "A batch that is `None` was added to {}. This can be "
+                    "normal at the beginning of execution but might "
+                    "indicate an issue.".format(type(self).__name__)
+                )
+            return
+        # Make a copy so the replay buffer doesn't pin plasma memory.
+        batch = batch.copy()
+        # Handle everything as if multi-agent.
+        batch = batch.as_multi_agent()
+
+        with self.add_batch_timer:
+            pids_and_batches = self._maybe_split_into_policy_batches(batch)
+            for policy_id, sample_batch in pids_and_batches.items():
+                self._add_to_underlying_buffer(policy_id, sample_batch, **kwargs)
+
+        self._num_added += batch.count
+
+    @DeveloperAPI
+    def _add_to_underlying_buffer(
+        self, policy_id: PolicyID, batch: SampleBatchType, **kwargs
+    ) -> None:
+        """Add a batch of experiences to the underlying buffer of a policy.
+
+        If the storage unit is `timesteps`, cut the batch into timeslices
+        before adding them to the appropriate buffer. Otherwise, let the
+        underlying buffer decide how slice batches.
+
+        Args:
+            policy_id: ID of the policy that corresponds to the underlying
+            buffer
+            batch: SampleBatch to add to the underlying buffer
+            ``**kwargs``: Forward compatibility kwargs.
+        """
+        # Merge kwargs, overwriting standard call arguments
+        kwargs = merge_dicts_with_warning(self.underlying_buffer_call_args, kwargs)
+
+        # For the storage unit `timesteps`, the underlying buffer will
+        # simply store the samples how they arrive. For sequences and
+        # episodes, the underlying buffer may split them itself.
+        if self.storage_unit is StorageUnit.TIMESTEPS:
+            timeslices = batch.timeslices(1)
+        elif self.storage_unit is StorageUnit.SEQUENCES:
+            timeslices = timeslice_along_seq_lens_with_overlap(
+                sample_batch=batch,
+                seq_lens=batch.get(SampleBatch.SEQ_LENS)
+                if self.replay_sequence_override
+                else None,
+                zero_pad_max_seq_len=self.replay_sequence_length,
+                pre_overlap=self.replay_burn_in,
+                zero_init_states=self.replay_zero_init_states,
+            )
+        elif self.storage_unit == StorageUnit.EPISODES:
+            timeslices = []
+            for eps in batch.split_by_episode():
+                if eps.get(SampleBatch.T)[0] == 0 and (
+                    eps.get(SampleBatch.TERMINATEDS, [True])[-1]
+                    or eps.get(SampleBatch.TRUNCATEDS, [False])[-1]
+                ):
+                    # Only add full episodes to the buffer
+                    timeslices.append(eps)
+                else:
+                    if log_once("only_full_episodes"):
+                        logger.info(
+                            "This buffer uses episodes as a storage "
+                            "unit and thus allows only full episodes "
+                            "to be added to it. Some samples may be "
+                            "dropped."
+                        )
+        elif self.storage_unit == StorageUnit.FRAGMENTS:
+            timeslices = [batch]
+        else:
+            raise ValueError("Unknown `storage_unit={}`".format(self.storage_unit))
+
+        for slice in timeslices:
+            self.replay_buffers[policy_id].add(slice, **kwargs)
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def sample(
+        self, num_items: int, policy_id: Optional[PolicyID] = None, **kwargs
+    ) -> Optional[SampleBatchType]:
+        """Samples a MultiAgentBatch of `num_items` per one policy's buffer.
+
+        If less than `num_items` records are in the policy's buffer,
+        some samples in the results may be repeated to fulfil the batch size
+        `num_items` request. Returns an empty batch if there are no items in
+        the buffer.
+
+        Args:
+            num_items: Number of items to sample from a policy's buffer.
+            policy_id: ID of the policy that created the experiences we sample. If
+            none is given, sample from all policies.
+
+        Returns:
+            Concatenated MultiAgentBatch of items.
+            ``**kwargs``: Forward compatibility kwargs.
+        """
+        # Merge kwargs, overwriting standard call arguments
+        kwargs = merge_dicts_with_warning(self.underlying_buffer_call_args, kwargs)
+
+        with self.replay_timer:
+            # Lockstep mode: Sample from all policies at the same time an
+            # equal amount of steps.
+            if self.replay_mode == ReplayMode.LOCKSTEP:
+                assert (
+                    policy_id is None
+                ), "`policy_id` specifier not allowed in `lockstep` mode!"
+                # In lockstep mode we sample MultiAgentBatches
+                return self.replay_buffers[_ALL_POLICIES].sample(num_items, **kwargs)
+            elif policy_id is not None:
+                sample = self.replay_buffers[policy_id].sample(num_items, **kwargs)
+                return MultiAgentBatch({policy_id: sample}, sample.count)
+            else:
+                samples = {}
+                for policy_id, replay_buffer in self.replay_buffers.items():
+                    samples[policy_id] = replay_buffer.sample(num_items, **kwargs)
+                return MultiAgentBatch(samples, sum(s.count for s in samples.values()))
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def stats(self, debug: bool = False) -> Dict:
+        """Returns the stats of this buffer and all underlying buffers.
+
+        Args:
+            debug: If True, stats of underlying replay buffers will
+            be fetched with debug=True.
+
+        Returns:
+            stat: Dictionary of buffer stats.
+        """
+        stat = {
+            "add_batch_time_ms": round(1000 * self.add_batch_timer.mean, 3),
+            "replay_time_ms": round(1000 * self.replay_timer.mean, 3),
+        }
+        for policy_id, replay_buffer in self.replay_buffers.items():
+            stat.update(
+                {"policy_{}".format(policy_id): replay_buffer.stats(debug=debug)}
+            )
+        return stat
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def get_state(self) -> Dict[str, Any]:
+        """Returns all local state.
+
+        Returns:
+            The serializable local state.
+        """
+        state = {"num_added": self._num_added, "replay_buffers": {}}
+        for policy_id, replay_buffer in self.replay_buffers.items():
+            state["replay_buffers"][policy_id] = replay_buffer.get_state()
+        return state
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def set_state(self, state: Dict[str, Any]) -> None:
+        """Restores all local state to the provided `state`.
+
+        Args:
+            state: The new state to set this buffer. Can be obtained by
+                calling `self.get_state()`.
+        """
+        self._num_added = state["num_added"]
+        buffer_states = state["replay_buffers"]
+        for policy_id in buffer_states.keys():
+            self.replay_buffers[policy_id].set_state(buffer_states[policy_id])
+
+    def _maybe_split_into_policy_batches(self, batch: SampleBatchType):
+        """Returns a dict of policy IDs and batches, depending on our replay mode.
+
+        This method helps with splitting up MultiAgentBatches only if the
+        self.replay_mode requires it.
+        """
+        if self.replay_mode == ReplayMode.LOCKSTEP:
+            return {_ALL_POLICIES: batch}
+        else:
+            return batch.policy_batches

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/replay_buffers/prioritized_replay_buffer.py

@@ -0,0 +1,240 @@
+import random
+from typing import Any, Dict, List, Optional
+import numpy as np
+
+# Import ray before psutil will make sure we use psutil's bundled version
+import ray  # noqa F401
+import psutil  # noqa E402
+
+from ray.rllib.execution.segment_tree import SumSegmentTree, MinSegmentTree
+from ray.rllib.policy.sample_batch import SampleBatch
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.metrics.window_stat import WindowStat
+from ray.rllib.utils.replay_buffers.replay_buffer import ReplayBuffer
+from ray.rllib.utils.typing import SampleBatchType
+from ray.util.annotations import DeveloperAPI
+
+
+@DeveloperAPI
+class PrioritizedReplayBuffer(ReplayBuffer):
+    """This buffer implements Prioritized Experience Replay.
+
+    The algorithm has been described by Tom Schaul et. al. in "Prioritized
+    Experience Replay". See https://arxiv.org/pdf/1511.05952.pdf for
+    the full paper.
+    """
+
+    def __init__(
+        self,
+        capacity: int = 10000,
+        storage_unit: str = "timesteps",
+        alpha: float = 1.0,
+        **kwargs
+    ):
+        """Initializes a PrioritizedReplayBuffer instance.
+
+        Args:
+            capacity: Max number of timesteps to store in the FIFO
+                buffer. After reaching this number, older samples will be
+                dropped to make space for new ones.
+            storage_unit: Either 'timesteps', 'sequences' or
+                'episodes'. Specifies how experiences are stored.
+            alpha: How much prioritization is used
+                (0.0=no prioritization, 1.0=full prioritization).
+            ``**kwargs``: Forward compatibility kwargs.
+        """
+        ReplayBuffer.__init__(self, capacity, storage_unit, **kwargs)
+
+        assert alpha > 0
+        self._alpha = alpha
+
+        # Segment tree must have capacity that is a power of 2
+        it_capacity = 1
+        while it_capacity < self.capacity:
+            it_capacity *= 2
+
+        self._it_sum = SumSegmentTree(it_capacity)
+        self._it_min = MinSegmentTree(it_capacity)
+        self._max_priority = 1.0
+        self._prio_change_stats = WindowStat("reprio", 1000)
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def _add_single_batch(self, item: SampleBatchType, **kwargs) -> None:
+        """Add a batch of experiences to self._storage with weight.
+
+        An item consists of either one or more timesteps, a sequence or an
+        episode. Differs from add() in that it does not consider the storage
+        unit or type of batch and simply stores it.
+
+        Args:
+            item: The item to be added.
+            ``**kwargs``: Forward compatibility kwargs.
+        """
+        weight = kwargs.get("weight", None)
+
+        if weight is None:
+            weight = self._max_priority
+
+        self._it_sum[self._next_idx] = weight**self._alpha
+        self._it_min[self._next_idx] = weight**self._alpha
+
+        ReplayBuffer._add_single_batch(self, item)
+
+    def _sample_proportional(self, num_items: int) -> List[int]:
+        res = []
+        for _ in range(num_items):
+            # TODO(szymon): should we ensure no repeats?
+            mass = random.random() * self._it_sum.sum(0, len(self._storage))
+            idx = self._it_sum.find_prefixsum_idx(mass)
+            res.append(idx)
+        return res
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def sample(
+        self, num_items: int, beta: float, **kwargs
+    ) -> Optional[SampleBatchType]:
+        """Sample `num_items` items from this buffer, including prio. weights.
+
+        Samples in the results may be repeated.
+
+        Examples for storage of SamplesBatches:
+        - If storage unit `timesteps` has been chosen and batches of
+        size 5 have been added, sample(5) will yield a concatenated batch of
+        15 timesteps.
+        - If storage unit 'sequences' has been chosen and sequences of
+        different lengths have been added, sample(5) will yield a concatenated
+        batch with a number of timesteps equal to the sum of timesteps in
+        the 5 sampled sequences.
+        - If storage unit 'episodes' has been chosen and episodes of
+        different lengths have been added, sample(5) will yield a concatenated
+        batch with a number of timesteps equal to the sum of timesteps in
+        the 5 sampled episodes.
+
+        Args:
+            num_items: Number of items to sample from this buffer.
+            beta: To what degree to use importance weights (0 - no corrections,
+            1 - full correction).
+            ``**kwargs``: Forward compatibility kwargs.
+
+        Returns:
+            Concatenated SampleBatch of items including "weights" and
+            "batch_indexes" fields denoting IS of each sampled
+            transition and original idxes in buffer of sampled experiences.
+        """
+        assert beta >= 0.0
+
+        if len(self) == 0:
+            raise ValueError("Trying to sample from an empty buffer.")
+
+        idxes = self._sample_proportional(num_items)
+
+        weights = []
+        batch_indexes = []
+        p_min = self._it_min.min() / self._it_sum.sum()
+        max_weight = (p_min * len(self)) ** (-beta)
+
+        for idx in idxes:
+            p_sample = self._it_sum[idx] / self._it_sum.sum()
+            weight = (p_sample * len(self)) ** (-beta)
+            count = self._storage[idx].count
+            # If zero-padded, count will not be the actual batch size of the
+            # data.
+            if (
+                isinstance(self._storage[idx], SampleBatch)
+                and self._storage[idx].zero_padded
+            ):
+                actual_size = self._storage[idx].max_seq_len
+            else:
+                actual_size = count
+            weights.extend([weight / max_weight] * actual_size)
+            batch_indexes.extend([idx] * actual_size)
+            self._num_timesteps_sampled += count
+        batch = self._encode_sample(idxes)
+
+        # Note: prioritization is not supported in multi agent lockstep
+        if isinstance(batch, SampleBatch):
+            batch["weights"] = np.array(weights)
+            batch["batch_indexes"] = np.array(batch_indexes)
+
+        return batch
+
+    @DeveloperAPI
+    def update_priorities(self, idxes: List[int], priorities: List[float]) -> None:
+        """Update priorities of items at given indices.
+
+        Sets priority of item at index idxes[i] in buffer
+        to priorities[i].
+
+        Args:
+            idxes: List of indices of items
+            priorities: List of updated priorities corresponding to items at the
+            idxes denoted by variable `idxes`.
+        """
+        # Making sure we don't pass in e.g. a torch tensor.
+        assert isinstance(
+            idxes, (list, np.ndarray)
+        ), "ERROR: `idxes` is not a list or np.ndarray, but {}!".format(
+            type(idxes).__name__
+        )
+        assert len(idxes) == len(priorities)
+        for idx, priority in zip(idxes, priorities):
+            assert priority > 0
+            assert 0 <= idx < len(self._storage)
+            delta = priority**self._alpha - self._it_sum[idx]
+            self._prio_change_stats.push(delta)
+            self._it_sum[idx] = priority**self._alpha
+            self._it_min[idx] = priority**self._alpha
+
+            self._max_priority = max(self._max_priority, priority)
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def stats(self, debug: bool = False) -> Dict:
+        """Returns the stats of this buffer.
+
+        Args:
+            debug: If true, adds sample eviction statistics to the returned stats dict.
+
+        Returns:
+            A dictionary of stats about this buffer.
+        """
+        parent = ReplayBuffer.stats(self, debug)
+        if debug:
+            parent.update(self._prio_change_stats.stats())
+        return parent
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def get_state(self) -> Dict[str, Any]:
+        """Returns all local state.
+
+        Returns:
+            The serializable local state.
+        """
+        # Get parent state.
+        state = super().get_state()
+        # Add prio weights.
+        state.update(
+            {
+                "sum_segment_tree": self._it_sum.get_state(),
+                "min_segment_tree": self._it_min.get_state(),
+                "max_priority": self._max_priority,
+            }
+        )
+        return state
+
+    @DeveloperAPI
+    @override(ReplayBuffer)
+    def set_state(self, state: Dict[str, Any]) -> None:
+        """Restores all local state to the provided `state`.
+
+        Args:
+            state: The new state to set this buffer. Can be obtained by calling
+            `self.get_state()`.
+        """
+        super().set_state(state)
+        self._it_sum.set_state(state["sum_segment_tree"])
+        self._it_min.set_state(state["min_segment_tree"])
+        self._max_priority = state["max_priority"]

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/replay_buffers/replay_buffer.py

@@ -0,0 +1,374 @@
+from enum import Enum
+import logging
+import numpy as np
+import random
+from typing import Any, Dict, List, Optional, Union
+
+# Import ray before psutil will make sure we use psutil's bundled version
+import ray  # noqa F401
+import psutil
+
+from ray.rllib.policy.sample_batch import SampleBatch, concat_samples
+from ray.rllib.utils.actor_manager import FaultAwareApply
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.metrics.window_stat import WindowStat
+from ray.rllib.utils.replay_buffers.base import ReplayBufferInterface
+from ray.rllib.utils.typing import SampleBatchType
+from ray.util.annotations import DeveloperAPI
+from ray.util.debug import log_once
+
+# Constant that represents all policies in lockstep replay mode.
+_ALL_POLICIES = "__all__"
+
+logger = logging.getLogger(__name__)
+
+
+@DeveloperAPI
+class StorageUnit(Enum):
+    """Specifies how batches are structured in a ReplayBuffer.
+
+    timesteps: One buffer slot per timestep.
+    sequences: One buffer slot per sequence.
+    episodes: One buffer slot per episode.
+    fragemts: One buffer slot per incoming batch.
+    """
+
+    TIMESTEPS = "timesteps"
+    SEQUENCES = "sequences"
+    EPISODES = "episodes"
+    FRAGMENTS = "fragments"
+
+
+@DeveloperAPI
+def warn_replay_capacity(*, item: SampleBatchType, num_items: int) -> None:
+    """Warn if the configured replay buffer capacity is too large."""
+    if log_once("replay_capacity"):
+        item_size = item.size_bytes()
+        psutil_mem = psutil.virtual_memory()
+        total_gb = psutil_mem.total / 1e9
+        mem_size = num_items * item_size / 1e9
+        msg = (
+            "Estimated max memory usage for replay buffer is {} GB "
+            "({} batches of size {}, {} bytes each), "
+            "available system memory is {} GB".format(
+                mem_size, num_items, item.count, item_size, total_gb
+            )
+        )
+        if mem_size > total_gb:
+            raise ValueError(msg)
+        elif mem_size > 0.2 * total_gb:
+            logger.warning(msg)
+        else:
+            logger.info(msg)
+
+
+@DeveloperAPI
+class ReplayBuffer(ReplayBufferInterface, FaultAwareApply):
+    """The lowest-level replay buffer interface used by RLlib.
+
+    This class implements a basic ring-type of buffer with random sampling.
+    ReplayBuffer is the base class for advanced types that add functionality while
+    retaining compatibility through inheritance.
+
+    The following examples show how buffers behave with different storage_units
+    and capacities. This behaviour is generally similar for other buffers, although
+    they might not implement all storage_units.
+
+    Examples:
+
+    .. testcode::
+
+        from ray.rllib.utils.replay_buffers.replay_buffer import ReplayBuffer
+        from ray.rllib.utils.replay_buffers.replay_buffer import StorageUnit
+        from ray.rllib.policy.sample_batch import SampleBatch
+
+        # Store any batch as a whole
+        buffer = ReplayBuffer(capacity=10, storage_unit=StorageUnit.FRAGMENTS)
+        buffer.add(SampleBatch({"a": [1], "b": [2, 3, 4]}))
+        buffer.sample(1)
+
+        # Store only complete episodes
+        buffer = ReplayBuffer(capacity=10,
+                                storage_unit=StorageUnit.EPISODES)
+        buffer.add(SampleBatch({"c": [1, 2, 3, 4],
+                                SampleBatch.T: [0, 1, 0, 1],
+                                SampleBatch.TERMINATEDS: [False, True, False, True],
+                                SampleBatch.EPS_ID: [0, 0, 1, 1]}))
+        buffer.sample(1)
+
+        # Store single timesteps
+        buffer = ReplayBuffer(capacity=2, storage_unit=StorageUnit.TIMESTEPS)
+        buffer.add(SampleBatch({"a": [1, 2], SampleBatch.T: [0, 1]}))
+        buffer.sample(1)
+
+        buffer.add(SampleBatch({"a": [3], SampleBatch.T: [2]}))
+        print(buffer._eviction_started)
+        buffer.sample(1)
+
+        buffer = ReplayBuffer(capacity=10, storage_unit=StorageUnit.SEQUENCES)
+        buffer.add(SampleBatch({"c": [1, 2, 3], SampleBatch.SEQ_LENS: [1, 2]}))
+        buffer.sample(1)
+
+    .. testoutput::
+
+        True
+
+    `True` is not the output of the above testcode, but an artifact of unexpected
+    behaviour of sphinx doctests.
+    (see https://github.com/ray-project/ray/pull/32477#discussion_r1106776101)
+    """
+
+    def __init__(
+        self,
+        capacity: int = 10000,
+        storage_unit: Union[str, StorageUnit] = "timesteps",
+        **kwargs,
+    ):
+        """Initializes a (FIFO) ReplayBuffer instance.
+
+        Args:
+            capacity: Max number of timesteps to store in this FIFO
+                buffer. After reaching this number, older samples will be
+                dropped to make space for new ones.
+            storage_unit: If not a StorageUnit, either 'timesteps', 'sequences' or
+                'episodes'. Specifies how experiences are stored.
+            ``**kwargs``: Forward compatibility kwargs.
+        """
+
+        if storage_unit in ["timesteps", StorageUnit.TIMESTEPS]:
+            self.storage_unit = StorageUnit.TIMESTEPS
+        elif storage_unit in ["sequences", StorageUnit.SEQUENCES]:
+            self.storage_unit = StorageUnit.SEQUENCES
+        elif storage_unit in ["episodes", StorageUnit.EPISODES]:
+            self.storage_unit = StorageUnit.EPISODES
+        elif storage_unit in ["fragments", StorageUnit.FRAGMENTS]:
+            self.storage_unit = StorageUnit.FRAGMENTS
+        else:
+            raise ValueError(
+                f"storage_unit must be either '{StorageUnit.TIMESTEPS}', "
+                f"'{StorageUnit.SEQUENCES}', '{StorageUnit.EPISODES}' "
+                f"or '{StorageUnit.FRAGMENTS}', but is {storage_unit}"
+            )
+
+        # The actual storage (list of SampleBatches or MultiAgentBatches).
+        self._storage = []
+
+        # Caps the number of timesteps stored in this buffer
+        if capacity <= 0:
+            raise ValueError(
+                "Capacity of replay buffer has to be greater than zero "
+                "but was set to {}.".format(capacity)
+            )
+        self.capacity = capacity
+        # The next index to override in the buffer.
+        self._next_idx = 0
+        # len(self._hit_count) must always be less than len(capacity)
+        self._hit_count = np.zeros(self.capacity)
+
+        # Whether we have already hit our capacity (and have therefore
+        # started to evict older samples).
+        self._eviction_started = False
+
+        # Number of (single) timesteps that have been added to the buffer
+        # over its lifetime. Note that each added item (batch) may contain
+        # more than one timestep.
+        self._num_timesteps_added = 0
+        self._num_timesteps_added_wrap = 0
+
+        # Number of (single) timesteps that have been sampled from the buffer
+        # over its lifetime.
+        self._num_timesteps_sampled = 0
+
+        self._evicted_hit_stats = WindowStat("evicted_hit", 1000)
+        self._est_size_bytes = 0
+
+        self.batch_size = None
+
+    @override(ReplayBufferInterface)
+    def __len__(self) -> int:
+        return len(self._storage)
+
+    @override(ReplayBufferInterface)
+    def add(self, batch: SampleBatchType, **kwargs) -> None:
+        """Adds a batch of experiences or other data to this buffer.
+
+        Splits batch into chunks of timesteps, sequences or episodes, depending on
+        `self._storage_unit`. Calls `self._add_single_batch` to add resulting slices
+        to the buffer storage.
+
+        Args:
+            batch: The batch to add.
+            ``**kwargs``: Forward compatibility kwargs.
+        """
+        if not batch.count > 0:
+            return
+
+        warn_replay_capacity(item=batch, num_items=self.capacity / batch.count)
+
+        if self.storage_unit == StorageUnit.TIMESTEPS:
+            timeslices = batch.timeslices(1)
+            for t in timeslices:
+                self._add_single_batch(t, **kwargs)
+
+        elif self.storage_unit == StorageUnit.SEQUENCES:
+            timestep_count = 0
+            for seq_len in batch.get(SampleBatch.SEQ_LENS):
+                start_seq = timestep_count
+                end_seq = timestep_count + seq_len
+                self._add_single_batch(batch[start_seq:end_seq], **kwargs)
+                timestep_count = end_seq
+
+        elif self.storage_unit == StorageUnit.EPISODES:
+            for eps in batch.split_by_episode():
+                if eps.get(SampleBatch.T, [0])[0] == 0 and (
+                    eps.get(SampleBatch.TERMINATEDS, [True])[-1]
+                    or eps.get(SampleBatch.TRUNCATEDS, [False])[-1]
+                ):
+                    # Only add full episodes to the buffer
+                    # Check only if info is available
+                    self._add_single_batch(eps, **kwargs)
+                else:
+                    if log_once("only_full_episodes"):
+                        logger.info(
+                            "This buffer uses episodes as a storage "
+                            "unit and thus allows only full episodes "
+                            "to be added to it (starting from T=0 and ending in "
+                            "`terminateds=True` or `truncateds=True`. "
+                            "Some samples may be dropped."
+                        )
+
+        elif self.storage_unit == StorageUnit.FRAGMENTS:
+            self._add_single_batch(batch, **kwargs)
+
+    @DeveloperAPI
+    def _add_single_batch(self, item: SampleBatchType, **kwargs) -> None:
+        """Add a SampleBatch of experiences to self._storage.
+
+        An item consists of either one or more timesteps, a sequence or an
+        episode. Differs from add() in that it does not consider the storage
+        unit or type of batch and simply stores it.
+
+        Args:
+            item: The batch to be added.
+            ``**kwargs``: Forward compatibility kwargs.
+        """
+        self._num_timesteps_added += item.count
+        self._num_timesteps_added_wrap += item.count
+
+        if self._next_idx >= len(self._storage):
+            self._storage.append(item)
+            self._est_size_bytes += item.size_bytes()
+        else:
+            item_to_be_removed = self._storage[self._next_idx]
+            self._est_size_bytes -= item_to_be_removed.size_bytes()
+            self._storage[self._next_idx] = item
+            self._est_size_bytes += item.size_bytes()
+
+        # Eviction of older samples has already started (buffer is "full").
+        if self._eviction_started:
+            self._evicted_hit_stats.push(self._hit_count[self._next_idx])
+            self._hit_count[self._next_idx] = 0
+
+        # Wrap around storage as a circular buffer once we hit capacity.
+        if self._num_timesteps_added_wrap >= self.capacity:
+            self._eviction_started = True
+            self._num_timesteps_added_wrap = 0
+            self._next_idx = 0
+        else:
+            self._next_idx += 1
+
+    @override(ReplayBufferInterface)
+    def sample(
+        self, num_items: Optional[int] = None, **kwargs
+    ) -> Optional[SampleBatchType]:
+        """Samples `num_items` items from this buffer.
+
+        The items depend on the buffer's storage_unit.
+        Samples in the results may be repeated.
+
+        Examples for sampling results:
+
+        1) If storage unit 'timesteps' has been chosen and batches of
+        size 5 have been added, sample(5) will yield a concatenated batch of
+        15 timesteps.
+
+        2) If storage unit 'sequences' has been chosen and sequences of
+        different lengths have been added, sample(5) will yield a concatenated
+        batch with a number of timesteps equal to the sum of timesteps in
+        the 5 sampled sequences.
+
+        3) If storage unit 'episodes' has been chosen and episodes of
+        different lengths have been added, sample(5) will yield a concatenated
+        batch with a number of timesteps equal to the sum of timesteps in
+        the 5 sampled episodes.
+
+        Args:
+            num_items: Number of items to sample from this buffer.
+            ``**kwargs``: Forward compatibility kwargs.
+
+        Returns:
+            Concatenated batch of items.
+        """
+        if len(self) == 0:
+            raise ValueError("Trying to sample from an empty buffer.")
+        idxes = [random.randint(0, len(self) - 1) for _ in range(num_items)]
+        sample = self._encode_sample(idxes)
+        self._num_timesteps_sampled += sample.count
+        return sample
+
+    @DeveloperAPI
+    def stats(self, debug: bool = False) -> dict:
+        """Returns the stats of this buffer.
+
+        Args:
+            debug: If True, adds sample eviction statistics to the returned
+                stats dict.
+
+        Returns:
+            A dictionary of stats about this buffer.
+        """
+        data = {
+            "added_count": self._num_timesteps_added,
+            "added_count_wrapped": self._num_timesteps_added_wrap,
+            "eviction_started": self._eviction_started,
+            "sampled_count": self._num_timesteps_sampled,
+            "est_size_bytes": self._est_size_bytes,
+            "num_entries": len(self._storage),
+        }
+        if debug:
+            data.update(self._evicted_hit_stats.stats())
+        return data
+
+    @override(ReplayBufferInterface)
+    def get_state(self) -> Dict[str, Any]:
+        state = {"_storage": self._storage, "_next_idx": self._next_idx}
+        state.update(self.stats(debug=False))
+        return state
+
+    @override(ReplayBufferInterface)
+    def set_state(self, state: Dict[str, Any]) -> None:
+        # The actual storage.
+        self._storage = state["_storage"]
+        self._next_idx = state["_next_idx"]
+        # Stats and counts.
+        self._num_timesteps_added = state["added_count"]
+        self._num_timesteps_added_wrap = state["added_count_wrapped"]
+        self._eviction_started = state["eviction_started"]
+        self._num_timesteps_sampled = state["sampled_count"]
+        self._est_size_bytes = state["est_size_bytes"]
+
+    @DeveloperAPI
+    def _encode_sample(self, idxes: List[int]) -> SampleBatchType:
+        """Fetches concatenated samples at given indices from the storage."""
+        samples = []
+        for i in idxes:
+            self._hit_count[i] += 1
+            samples.append(self._storage[i])
+
+        if samples:
+            # We assume all samples are of same type
+            out = concat_samples(samples)
+        else:
+            out = SampleBatch()
+        out.decompress_if_needed()
+        return out

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/replay_buffers/reservoir_replay_buffer.py

@@ -0,0 +1,132 @@
+from typing import Any, Dict
+import random
+
+# Import ray before psutil will make sure we use psutil's bundled version
+import ray  # noqa F401
+import psutil  # noqa E402
+
+from ray.rllib.utils.annotations import ExperimentalAPI, override
+from ray.rllib.utils.replay_buffers.replay_buffer import (
+    ReplayBuffer,
+    warn_replay_capacity,
+)
+from ray.rllib.utils.typing import SampleBatchType
+
+
+# __sphinx_doc_reservoir_buffer__begin__
+@ExperimentalAPI
+class ReservoirReplayBuffer(ReplayBuffer):
+    """This buffer implements reservoir sampling.
+
+    The algorithm has been described by Jeffrey S. Vitter in "Random sampling
+    with a reservoir".
+    """
+
+    def __init__(
+        self, capacity: int = 10000, storage_unit: str = "timesteps", **kwargs
+    ):
+        """Initializes a ReservoirBuffer instance.
+
+        Args:
+            capacity: Max number of timesteps to store in the FIFO
+                    buffer. After reaching this number, older samples will be
+                    dropped to make space for new ones.
+            storage_unit: Either 'timesteps', 'sequences' or
+                    'episodes'. Specifies how experiences are stored.
+        """
+        ReplayBuffer.__init__(self, capacity, storage_unit)
+        self._num_add_calls = 0
+        self._num_evicted = 0
+
+    @ExperimentalAPI
+    @override(ReplayBuffer)
+    def _add_single_batch(self, item: SampleBatchType, **kwargs) -> None:
+        """Add a SampleBatch of experiences to self._storage.
+
+        An item consists of either one or more timesteps, a sequence or an
+        episode. Differs from add() in that it does not consider the storage
+        unit or type of batch and simply stores it.
+
+        Args:
+            item: The batch to be added.
+            ``**kwargs``: Forward compatibility kwargs.
+        """
+        self._num_timesteps_added += item.count
+        self._num_timesteps_added_wrap += item.count
+
+        # Update add counts.
+        self._num_add_calls += 1
+        # Update our timesteps counts.
+
+        if self._num_timesteps_added < self.capacity:
+            self._storage.append(item)
+            self._est_size_bytes += item.size_bytes()
+        else:
+            # Eviction of older samples has already started (buffer is "full")
+            self._eviction_started = True
+            idx = random.randint(0, self._num_add_calls - 1)
+            if idx < len(self._storage):
+                self._num_evicted += 1
+                self._evicted_hit_stats.push(self._hit_count[idx])
+                self._hit_count[idx] = 0
+                # This is a bit of a hack: ReplayBuffer always inserts at
+                # self._next_idx
+                self._next_idx = idx
+                self._evicted_hit_stats.push(self._hit_count[idx])
+                self._hit_count[idx] = 0
+
+                item_to_be_removed = self._storage[idx]
+                self._est_size_bytes -= item_to_be_removed.size_bytes()
+                self._storage[idx] = item
+                self._est_size_bytes += item.size_bytes()
+
+                assert item.count > 0, item
+                warn_replay_capacity(item=item, num_items=self.capacity / item.count)
+
+    @ExperimentalAPI
+    @override(ReplayBuffer)
+    def stats(self, debug: bool = False) -> dict:
+        """Returns the stats of this buffer.
+
+        Args:
+            debug: If True, adds sample eviction statistics to the returned
+                    stats dict.
+
+        Returns:
+            A dictionary of stats about this buffer.
+        """
+        data = {
+            "num_evicted": self._num_evicted,
+            "num_add_calls": self._num_add_calls,
+        }
+        parent = ReplayBuffer.stats(self, debug)
+        parent.update(data)
+        return parent
+
+    @ExperimentalAPI
+    @override(ReplayBuffer)
+    def get_state(self) -> Dict[str, Any]:
+        """Returns all local state.
+
+        Returns:
+            The serializable local state.
+        """
+        parent = ReplayBuffer.get_state(self)
+        parent.update(self.stats())
+        return parent
+
+    @ExperimentalAPI
+    @override(ReplayBuffer)
+    def set_state(self, state: Dict[str, Any]) -> None:
+        """Restores all local state to the provided `state`.
+
+        Args:
+            state: The new state to set this buffer. Can be
+                    obtained by calling `self.get_state()`.
+        """
+        self._num_evicted = state["num_evicted"]
+        self._num_add_calls = state["num_add_calls"]
+        ReplayBuffer.set_state(self, state)
+
+
+# __sphinx_doc_reservoir_buffer__end__

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/replay_buffers/utils.py

@@ -0,0 +1,440 @@
+import logging
+import psutil
+from typing import Any, Dict, Optional
+
+import numpy as np
+
+from ray.rllib.utils import deprecation_warning
+from ray.rllib.utils.annotations import OldAPIStack
+from ray.rllib.utils.deprecation import DEPRECATED_VALUE
+from ray.rllib.utils.from_config import from_config
+from ray.rllib.utils.metrics import ALL_MODULES, TD_ERROR_KEY
+from ray.rllib.utils.metrics.learner_info import LEARNER_STATS_KEY
+from ray.rllib.utils.replay_buffers import (
+    EpisodeReplayBuffer,
+    MultiAgentPrioritizedReplayBuffer,
+    PrioritizedEpisodeReplayBuffer,
+    ReplayBuffer,
+    MultiAgentReplayBuffer,
+)
+from ray.rllib.policy.sample_batch import concat_samples, MultiAgentBatch, SampleBatch
+from ray.rllib.utils.typing import (
+    AlgorithmConfigDict,
+    ModuleID,
+    ResultDict,
+    SampleBatchType,
+    TensorType,
+)
+from ray.util import log_once
+from ray.util.annotations import DeveloperAPI
+
+logger = logging.getLogger(__name__)
+
+
+@DeveloperAPI
+def update_priorities_in_episode_replay_buffer(
+    *,
+    replay_buffer: EpisodeReplayBuffer,
+    td_errors: Dict[ModuleID, TensorType],
+) -> None:
+    # Only update priorities, if the buffer supports them.
+    if isinstance(replay_buffer, PrioritizedEpisodeReplayBuffer):
+
+        # The `ResultDict` will be multi-agent.
+        for module_id, td_error in td_errors.items():
+            # Skip the `"__all__"` keys.
+            if module_id in ["__all__", ALL_MODULES]:
+                continue
+
+            # Warn once, if we have no TD-errors to update priorities.
+            if TD_ERROR_KEY not in td_error or td_error[TD_ERROR_KEY] is None:
+                if log_once(
+                    "no_td_error_in_train_results_from_module_{}".format(module_id)
+                ):
+                    logger.warning(
+                        "Trying to update priorities for module with ID "
+                        f"`{module_id}` in prioritized episode replay buffer without "
+                        "providing `td_errors` in train_results. Priority update for "
+                        "this policy is being skipped."
+                    )
+                continue
+            # TODO (simon): Implement multi-agent version. Remove, happens in buffer.
+            # assert len(td_error[TD_ERROR_KEY]) == len(
+            #     replay_buffer._last_sampled_indices
+            # )
+            # TODO (simon): Implement for stateful modules.
+
+            replay_buffer.update_priorities(td_error[TD_ERROR_KEY], module_id)
+
+
+@OldAPIStack
+def update_priorities_in_replay_buffer(
+    replay_buffer: ReplayBuffer,
+    config: AlgorithmConfigDict,
+    train_batch: SampleBatchType,
+    train_results: ResultDict,
+) -> None:
+    """Updates the priorities in a prioritized replay buffer, given training results.
+
+    The `abs(TD-error)` from the loss (inside `train_results`) is used as new
+    priorities for the row-indices that were sampled for the train batch.
+
+    Don't do anything if the given buffer does not support prioritized replay.
+
+    Args:
+        replay_buffer: The replay buffer, whose priority values to update. This may also
+            be a buffer that does not support priorities.
+        config: The Algorithm's config dict.
+        train_batch: The batch used for the training update.
+        train_results: A train results dict, generated by e.g. the `train_one_step()`
+            utility.
+    """
+    # Only update priorities if buffer supports them.
+    if isinstance(replay_buffer, MultiAgentPrioritizedReplayBuffer):
+        # Go through training results for the different policies (maybe multi-agent).
+        prio_dict = {}
+        for policy_id, info in train_results.items():
+            # TODO(sven): This is currently structured differently for
+            #  torch/tf. Clean up these results/info dicts across
+            #  policies (note: fixing this in torch_policy.py will
+            #  break e.g. DDPPO!).
+            td_error = info.get("td_error", info[LEARNER_STATS_KEY].get("td_error"))
+
+            policy_batch = train_batch.policy_batches[policy_id]
+            # Set the get_interceptor to None in order to be able to access the numpy
+            # arrays directly (instead of e.g. a torch array).
+            policy_batch.set_get_interceptor(None)
+            # Get the replay buffer row indices that make up the `train_batch`.
+            batch_indices = policy_batch.get("batch_indexes")
+
+            if SampleBatch.SEQ_LENS in policy_batch:
+                # Batch_indices are represented per column, in order to update
+                # priorities, we need one index per td_error
+                _batch_indices = []
+
+                # Sequenced batches have been zero padded to max_seq_len.
+                # Depending on how batches are split during learning, not all
+                # sequences have an associated td_error (trailing ones missing).
+                if policy_batch.zero_padded:
+                    seq_lens = len(td_error) * [policy_batch.max_seq_len]
+                else:
+                    seq_lens = policy_batch[SampleBatch.SEQ_LENS][: len(td_error)]
+
+                # Go through all indices by sequence that they represent and shrink
+                # them to one index per sequences
+                sequence_sum = 0
+                for seq_len in seq_lens:
+                    _batch_indices.append(batch_indices[sequence_sum])
+                    sequence_sum += seq_len
+                batch_indices = np.array(_batch_indices)
+
+            if td_error is None:
+                if log_once(
+                    "no_td_error_in_train_results_from_policy_{}".format(policy_id)
+                ):
+                    logger.warning(
+                        "Trying to update priorities for policy with id `{}` in "
+                        "prioritized replay buffer without providing td_errors in "
+                        "train_results. Priority update for this policy is being "
+                        "skipped.".format(policy_id)
+                    )
+                continue
+
+            if batch_indices is None:
+                if log_once(
+                    "no_batch_indices_in_train_result_for_policy_{}".format(policy_id)
+                ):
+                    logger.warning(
+                        "Trying to update priorities for policy with id `{}` in "
+                        "prioritized replay buffer without providing batch_indices in "
+                        "train_batch. Priority update for this policy is being "
+                        "skipped.".format(policy_id)
+                    )
+                continue
+
+            #  Try to transform batch_indices to td_error dimensions
+            if len(batch_indices) != len(td_error):
+                T = replay_buffer.replay_sequence_length
+                assert (
+                    len(batch_indices) > len(td_error) and len(batch_indices) % T == 0
+                )
+                batch_indices = batch_indices.reshape([-1, T])[:, 0]
+                assert len(batch_indices) == len(td_error)
+            prio_dict[policy_id] = (batch_indices, td_error)
+
+        # Make the actual buffer API call to update the priority weights on all
+        # policies.
+        replay_buffer.update_priorities(prio_dict)
+
+
+@DeveloperAPI
+def sample_min_n_steps_from_buffer(
+    replay_buffer: ReplayBuffer, min_steps: int, count_by_agent_steps: bool
+) -> Optional[SampleBatchType]:
+    """Samples a minimum of n timesteps from a given replay buffer.
+
+    This utility method is primarily used by the QMIX algorithm and helps with
+    sampling a given number of time steps which has stored samples in units
+    of sequences or complete episodes. Samples n batches from replay buffer
+    until the total number of timesteps reaches `train_batch_size`.
+
+    Args:
+        replay_buffer: The replay buffer to sample from
+        num_timesteps: The number of timesteps to sample
+        count_by_agent_steps: Whether to count agent steps or env steps
+
+    Returns:
+        A concatenated SampleBatch or MultiAgentBatch with samples from the
+        buffer.
+    """
+    train_batch_size = 0
+    train_batches = []
+    while train_batch_size < min_steps:
+        batch = replay_buffer.sample(num_items=1)
+        batch_len = batch.agent_steps() if count_by_agent_steps else batch.env_steps()
+        if batch_len == 0:
+            # Replay has not started, so we can't accumulate timesteps here
+            return batch
+        train_batches.append(batch)
+        train_batch_size += batch_len
+    # All batch types are the same type, hence we can use any concat_samples()
+    train_batch = concat_samples(train_batches)
+    return train_batch
+
+
+@DeveloperAPI
+def validate_buffer_config(config: dict) -> None:
+    """Checks and fixes values in the replay buffer config.
+
+    Checks the replay buffer config for common misconfigurations, warns or raises
+    error in case validation fails. The type "key" is changed into the inferred
+    replay buffer class.
+
+    Args:
+        config: The replay buffer config to be validated.
+
+    Raises:
+        ValueError: When detecting severe misconfiguration.
+    """
+    if config.get("replay_buffer_config", None) is None:
+        config["replay_buffer_config"] = {}
+
+    if config.get("worker_side_prioritization", DEPRECATED_VALUE) != DEPRECATED_VALUE:
+        deprecation_warning(
+            old="config['worker_side_prioritization']",
+            new="config['replay_buffer_config']['worker_side_prioritization']",
+            error=True,
+        )
+
+    prioritized_replay = config.get("prioritized_replay", DEPRECATED_VALUE)
+    if prioritized_replay != DEPRECATED_VALUE:
+        deprecation_warning(
+            old="config['prioritized_replay'] or config['replay_buffer_config']["
+            "'prioritized_replay']",
+            help="Replay prioritization specified by config key. RLlib's new replay "
+            "buffer API requires setting `config["
+            "'replay_buffer_config']['type']`, e.g. `config["
+            "'replay_buffer_config']['type'] = "
+            "'MultiAgentPrioritizedReplayBuffer'` to change the default "
+            "behaviour.",
+            error=True,
+        )
+
+    capacity = config.get("buffer_size", DEPRECATED_VALUE)
+    if capacity == DEPRECATED_VALUE:
+        capacity = config["replay_buffer_config"].get("buffer_size", DEPRECATED_VALUE)
+    if capacity != DEPRECATED_VALUE:
+        deprecation_warning(
+            old="config['buffer_size'] or config['replay_buffer_config']["
+            "'buffer_size']",
+            new="config['replay_buffer_config']['capacity']",
+            error=True,
+        )
+
+    replay_burn_in = config.get("burn_in", DEPRECATED_VALUE)
+    if replay_burn_in != DEPRECATED_VALUE:
+        config["replay_buffer_config"]["replay_burn_in"] = replay_burn_in
+        deprecation_warning(
+            old="config['burn_in']",
+            help="config['replay_buffer_config']['replay_burn_in']",
+        )
+
+    replay_batch_size = config.get("replay_batch_size", DEPRECATED_VALUE)
+    if replay_batch_size == DEPRECATED_VALUE:
+        replay_batch_size = config["replay_buffer_config"].get(
+            "replay_batch_size", DEPRECATED_VALUE
+        )
+    if replay_batch_size != DEPRECATED_VALUE:
+        deprecation_warning(
+            old="config['replay_batch_size'] or config['replay_buffer_config']["
+            "'replay_batch_size']",
+            help="Specification of replay_batch_size is not supported anymore but is "
+            "derived from `train_batch_size`. Specify the number of "
+            "items you want to replay upon calling the sample() method of replay "
+            "buffers if this does not work for you.",
+            error=True,
+        )
+
+    # Deprecation of old-style replay buffer args
+    # Warnings before checking of we need local buffer so that algorithms
+    # Without local buffer also get warned
+    keys_with_deprecated_positions = [
+        "prioritized_replay_alpha",
+        "prioritized_replay_beta",
+        "prioritized_replay_eps",
+        "no_local_replay_buffer",
+        "replay_zero_init_states",
+        "replay_buffer_shards_colocated_with_driver",
+    ]
+    for k in keys_with_deprecated_positions:
+        if config.get(k, DEPRECATED_VALUE) != DEPRECATED_VALUE:
+            deprecation_warning(
+                old="config['{}']".format(k),
+                help="config['replay_buffer_config']['{}']" "".format(k),
+                error=False,
+            )
+            # Copy values over to new location in config to support new
+            # and old configuration style.
+            if config.get("replay_buffer_config") is not None:
+                config["replay_buffer_config"][k] = config[k]
+
+    learning_starts = config.get(
+        "learning_starts",
+        config.get("replay_buffer_config", {}).get("learning_starts", DEPRECATED_VALUE),
+    )
+    if learning_starts != DEPRECATED_VALUE:
+        deprecation_warning(
+            old="config['learning_starts'] or"
+            "config['replay_buffer_config']['learning_starts']",
+            help="config['num_steps_sampled_before_learning_starts']",
+            error=True,
+        )
+        config["num_steps_sampled_before_learning_starts"] = learning_starts
+
+    # Can't use DEPRECATED_VALUE here because this is also a deliberate
+    # value set for some algorithms
+    # TODO: (Artur): Compare to DEPRECATED_VALUE on deprecation
+    replay_sequence_length = config.get("replay_sequence_length", None)
+    if replay_sequence_length is not None:
+        config["replay_buffer_config"][
+            "replay_sequence_length"
+        ] = replay_sequence_length
+        deprecation_warning(
+            old="config['replay_sequence_length']",
+            help="Replay sequence length specified at new "
+            "location config['replay_buffer_config']["
+            "'replay_sequence_length'] will be overwritten.",
+            error=True,
+        )
+
+    replay_buffer_config = config["replay_buffer_config"]
+    assert (
+        "type" in replay_buffer_config
+    ), "Can not instantiate ReplayBuffer from config without 'type' key."
+
+    # Check if old replay buffer should be instantiated
+    buffer_type = config["replay_buffer_config"]["type"]
+
+    if isinstance(buffer_type, str) and buffer_type.find(".") == -1:
+        # Create valid full [module].[class] string for from_config
+        config["replay_buffer_config"]["type"] = (
+            "ray.rllib.utils.replay_buffers." + buffer_type
+        )
+
+    # Instantiate a dummy buffer to fail early on misconfiguration and find out about
+    # inferred buffer class
+    dummy_buffer = from_config(buffer_type, config["replay_buffer_config"])
+
+    config["replay_buffer_config"]["type"] = type(dummy_buffer)
+
+    if hasattr(dummy_buffer, "update_priorities"):
+        if (
+            config["replay_buffer_config"].get("replay_mode", "independent")
+            == "lockstep"
+        ):
+            raise ValueError(
+                "Prioritized replay is not supported when replay_mode=lockstep."
+            )
+        elif config["replay_buffer_config"].get("replay_sequence_length", 0) > 1:
+            raise ValueError(
+                "Prioritized replay is not supported when "
+                "replay_sequence_length > 1."
+            )
+    else:
+        if config["replay_buffer_config"].get("worker_side_prioritization"):
+            raise ValueError(
+                "Worker side prioritization is not supported when "
+                "prioritized_replay=False."
+            )
+
+
+@DeveloperAPI
+def warn_replay_buffer_capacity(*, item: SampleBatchType, capacity: int) -> None:
+    """Warn if the configured replay buffer capacity is too large for machine's memory.
+
+    Args:
+        item: A (example) item that's supposed to be added to the buffer.
+            This is used to compute the overall memory footprint estimate for the
+            buffer.
+        capacity: The capacity value of the buffer. This is interpreted as the
+            number of items (such as given `item`) that will eventually be stored in
+            the buffer.
+
+    Raises:
+        ValueError: If computed memory footprint for the buffer exceeds the machine's
+            RAM.
+    """
+    if log_once("warn_replay_buffer_capacity"):
+        item_size = item.size_bytes()
+        psutil_mem = psutil.virtual_memory()
+        total_gb = psutil_mem.total / 1e9
+        mem_size = capacity * item_size / 1e9
+        msg = (
+            "Estimated max memory usage for replay buffer is {} GB "
+            "({} batches of size {}, {} bytes each), "
+            "available system memory is {} GB".format(
+                mem_size, capacity, item.count, item_size, total_gb
+            )
+        )
+        if mem_size > total_gb:
+            raise ValueError(msg)
+        elif mem_size > 0.2 * total_gb:
+            logger.warning(msg)
+        else:
+            logger.info(msg)
+
+
+def patch_buffer_with_fake_sampling_method(
+    buffer: ReplayBuffer, fake_sample_output: SampleBatchType
+) -> None:
+    """Patch a ReplayBuffer such that we always sample fake_sample_output.
+
+    Transforms fake_sample_output into a MultiAgentBatch if it is not a
+    MultiAgentBatch and the buffer is a MultiAgentBuffer. This is useful for testing
+    purposes if we need deterministic sampling.
+
+    Args:
+        buffer: The buffer to be patched
+        fake_sample_output: The output to be sampled
+
+    """
+    if isinstance(buffer, MultiAgentReplayBuffer) and not isinstance(
+        fake_sample_output, MultiAgentBatch
+    ):
+        fake_sample_output = SampleBatch(fake_sample_output).as_multi_agent()
+
+    def fake_sample(_: Any = None, **kwargs) -> Optional[SampleBatchType]:
+        """Always returns a predefined batch.
+
+        Args:
+            _: dummy arg to match signature of sample() method
+            __: dummy arg to match signature of sample() method
+            ``**kwargs``: dummy args to match signature of sample() method
+
+        Returns:
+            Predefined MultiAgentBatch fake_sample_output
+        """
+
+        return fake_sample_output
+
+    buffer.sample = fake_sample

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/sgd.py

@@ -0,0 +1,136 @@
+"""Utils for minibatch SGD across multiple RLlib policies."""
+
+import logging
+import numpy as np
+import random
+
+from ray.rllib.utils.annotations import OldAPIStack
+from ray.rllib.policy.sample_batch import SampleBatch, MultiAgentBatch
+from ray.rllib.utils.metrics.learner_info import LearnerInfoBuilder
+
+logger = logging.getLogger(__name__)
+
+
+@OldAPIStack
+def standardized(array: np.ndarray):
+    """Normalize the values in an array.
+
+    Args:
+        array (np.ndarray): Array of values to normalize.
+
+    Returns:
+        array with zero mean and unit standard deviation.
+    """
+    return (array - array.mean()) / max(1e-4, array.std())
+
+
+@OldAPIStack
+def minibatches(samples: SampleBatch, sgd_minibatch_size: int, shuffle: bool = True):
+    """Return a generator yielding minibatches from a sample batch.
+
+    Args:
+        samples: SampleBatch to split up.
+        sgd_minibatch_size: Size of minibatches to return.
+        shuffle: Whether to shuffle the order of the generated minibatches.
+            Note that in case of a non-recurrent policy, the incoming batch
+            is globally shuffled first regardless of this setting, before
+            the minibatches are generated from it!
+
+    Yields:
+        SampleBatch: Each of size `sgd_minibatch_size`.
+    """
+    if not sgd_minibatch_size:
+        yield samples
+        return
+
+    if isinstance(samples, MultiAgentBatch):
+        raise NotImplementedError(
+            "Minibatching not implemented for multi-agent in simple mode"
+        )
+
+    if "state_in_0" not in samples and "state_out_0" not in samples:
+        samples.shuffle()
+
+    all_slices = samples._get_slice_indices(sgd_minibatch_size)
+    data_slices, state_slices = all_slices
+
+    if len(state_slices) == 0:
+        if shuffle:
+            random.shuffle(data_slices)
+        for i, j in data_slices:
+            yield samples[i:j]
+    else:
+        all_slices = list(zip(data_slices, state_slices))
+        if shuffle:
+            # Make sure to shuffle data and states while linked together.
+            random.shuffle(all_slices)
+        for (i, j), (si, sj) in all_slices:
+            yield samples.slice(i, j, si, sj)
+
+
+@OldAPIStack
+def do_minibatch_sgd(
+    samples,
+    policies,
+    local_worker,
+    num_sgd_iter,
+    sgd_minibatch_size,
+    standardize_fields,
+):
+    """Execute minibatch SGD.
+
+    Args:
+        samples: Batch of samples to optimize.
+        policies: Dictionary of policies to optimize.
+        local_worker: Master rollout worker instance.
+        num_sgd_iter: Number of epochs of optimization to take.
+        sgd_minibatch_size: Size of minibatches to use for optimization.
+        standardize_fields: List of sample field names that should be
+            normalized prior to optimization.
+
+    Returns:
+        averaged info fetches over the last SGD epoch taken.
+    """
+
+    # Handle everything as if multi-agent.
+    samples = samples.as_multi_agent()
+
+    # Use LearnerInfoBuilder as a unified way to build the final
+    # results dict from `learn_on_loaded_batch` call(s).
+    # This makes sure results dicts always have the same structure
+    # no matter the setup (multi-GPU, multi-agent, minibatch SGD,
+    # tf vs torch).
+    learner_info_builder = LearnerInfoBuilder(num_devices=1)
+    for policy_id, policy in policies.items():
+        if policy_id not in samples.policy_batches:
+            continue
+
+        batch = samples.policy_batches[policy_id]
+        for field in standardize_fields:
+            batch[field] = standardized(batch[field])
+
+        # Check to make sure that the sgd_minibatch_size is not smaller
+        # than max_seq_len otherwise this will cause indexing errors while
+        # performing sgd when using a RNN or Attention model
+        if (
+            policy.is_recurrent()
+            and policy.config["model"]["max_seq_len"] > sgd_minibatch_size
+        ):
+            raise ValueError(
+                "`sgd_minibatch_size` ({}) cannot be smaller than"
+                "`max_seq_len` ({}).".format(
+                    sgd_minibatch_size, policy.config["model"]["max_seq_len"]
+                )
+            )
+
+        for i in range(num_sgd_iter):
+            for minibatch in minibatches(batch, sgd_minibatch_size):
+                results = (
+                    local_worker.learn_on_batch(
+                        MultiAgentBatch({policy_id: minibatch}, minibatch.count)
+                    )
+                )[policy_id]
+                learner_info_builder.add_learn_on_batch_results(results, policy_id)
+
+    learner_info = learner_info_builder.finalize()
+    return learner_info

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/tensor_dtype.py

@@ -0,0 +1,65 @@
+import numpy as np
+
+from ray.rllib.utils.typing import TensorType
+from ray.rllib.utils.framework import try_import_torch, try_import_tf
+from ray.util.annotations import PublicAPI
+
+torch, _ = try_import_torch()
+_, tf, _ = try_import_tf()
+
+
+# Dict of NumPy dtype -> torch dtype
+if torch:
+    numpy_to_torch_dtype_dict = {
+        np.bool_: torch.bool,
+        np.uint8: torch.uint8,
+        np.int8: torch.int8,
+        np.int16: torch.int16,
+        np.int32: torch.int32,
+        np.int64: torch.int64,
+        np.float16: torch.float16,
+        np.float32: torch.float32,
+        np.float64: torch.float64,
+        np.complex64: torch.complex64,
+        np.complex128: torch.complex128,
+    }
+else:
+    numpy_to_torch_dtype_dict = {}
+
+# Dict of NumPy dtype -> tf dtype
+if tf:
+    numpy_to_tf_dtype_dict = {
+        np.bool_: tf.bool,
+        np.uint8: tf.uint8,
+        np.int8: tf.int8,
+        np.int16: tf.int16,
+        np.int32: tf.int32,
+        np.int64: tf.int64,
+        np.float16: tf.float16,
+        np.float32: tf.float32,
+        np.float64: tf.float64,
+        np.complex64: tf.complex64,
+        np.complex128: tf.complex128,
+    }
+else:
+    numpy_to_tf_dtype_dict = {}
+
+# Dict of torch dtype -> NumPy dtype
+torch_to_numpy_dtype_dict = {
+    value: key for (key, value) in numpy_to_torch_dtype_dict.items()
+}
+# Dict of tf dtype -> NumPy dtype
+tf_to_numpy_dtype_dict = {value: key for (key, value) in numpy_to_tf_dtype_dict.items()}
+
+
+@PublicAPI(stability="alpha")
+def get_np_dtype(x: TensorType) -> np.dtype:
+    """Returns the NumPy dtype of the given tensor or array."""
+    if torch and isinstance(x, torch.Tensor):
+        return torch_to_numpy_dtype_dict[x.dtype]
+    if tf and isinstance(x, tf.Tensor):
+        return tf_to_numpy_dtype_dict[x.dtype]
+    elif isinstance(x, np.ndarray):
+        return x.dtype
+    else:
+        raise TypeError("Unsupported type: {}".format(type(x)))

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/test_utils.py

@@ -0,0 +1,1817 @@
+import argparse
+import json
+import logging
+import os
+import pprint
+import random
+import re
+import time
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
+
+import gymnasium as gym
+from gymnasium.spaces import Box, Discrete, MultiDiscrete, MultiBinary
+from gymnasium.spaces import Dict as GymDict
+from gymnasium.spaces import Tuple as GymTuple
+import numpy as np
+import tree  # pip install dm_tree
+
+import ray
+from ray import air, tune
+from ray.air.constants import TRAINING_ITERATION
+from ray.air.integrations.wandb import WandbLoggerCallback, WANDB_ENV_VAR
+from ray.rllib.core import DEFAULT_MODULE_ID, Columns
+from ray.rllib.env.wrappers.atari_wrappers import is_atari, wrap_deepmind
+from ray.rllib.utils.annotations import OldAPIStack
+from ray.rllib.utils.framework import try_import_jax, try_import_tf, try_import_torch
+from ray.rllib.utils.metrics import (
+    DIFF_NUM_GRAD_UPDATES_VS_SAMPLER_POLICY,
+    ENV_RUNNER_RESULTS,
+    EPISODE_RETURN_MEAN,
+    EVALUATION_RESULTS,
+    NUM_ENV_STEPS_TRAINED,
+    NUM_ENV_STEPS_SAMPLED_LIFETIME,
+)
+from ray.rllib.utils.typing import ResultDict
+from ray.rllib.utils.error import UnsupportedSpaceException
+
+
+from ray.tune import CLIReporter
+
+
+if TYPE_CHECKING:
+    from ray.rllib.algorithms import Algorithm, AlgorithmConfig
+    from ray.rllib.offline.dataset_reader import DatasetReader
+
+jax, _ = try_import_jax()
+tf1, tf, tfv = try_import_tf()
+torch, _ = try_import_torch()
+
+logger = logging.getLogger(__name__)
+
+
+def add_rllib_example_script_args(
+    parser: Optional[argparse.ArgumentParser] = None,
+    default_reward: float = 100.0,
+    default_iters: int = 200,
+    default_timesteps: int = 100000,
+) -> argparse.ArgumentParser:
+    """Adds RLlib-typical (and common) examples scripts command line args to a parser.
+
+    TODO (sven): This function should be used by most of our examples scripts, which
+     already mostly have this logic in them (but written out).
+
+    Args:
+        parser: The parser to add the arguments to. If None, create a new one.
+        default_reward: The default value for the --stop-reward option.
+        default_iters: The default value for the --stop-iters option.
+        default_timesteps: The default value for the --stop-timesteps option.
+
+    Returns:
+        The altered (or newly created) parser object.
+    """
+    if parser is None:
+        parser = argparse.ArgumentParser()
+
+    # Algo and Algo config options.
+    parser.add_argument(
+        "--algo", type=str, default="PPO", help="The RLlib-registered algorithm to use."
+    )
+    parser.add_argument(
+        "--enable-new-api-stack",
+        action="store_true",
+        help="Whether to use the `enable_rl_module_and_learner` config setting.",
+    )
+    parser.add_argument(
+        "--framework",
+        choices=["tf", "tf2", "torch"],
+        default="torch",
+        help="The DL framework specifier.",
+    )
+    parser.add_argument(
+        "--env",
+        type=str,
+        default=None,
+        help="The gym.Env identifier to run the experiment with.",
+    )
+    parser.add_argument(
+        "--num-env-runners",
+        type=int,
+        default=None,
+        help="The number of (remote) EnvRunners to use for the experiment.",
+    )
+    parser.add_argument(
+        "--num-envs-per-env-runner",
+        type=int,
+        default=None,
+        help="The number of (vectorized) environments per EnvRunner. Note that "
+        "this is identical to the batch size for (inference) action computations.",
+    )
+    parser.add_argument(
+        "--num-agents",
+        type=int,
+        default=0,
+        help="If 0 (default), will run as single-agent. If > 0, will run as "
+        "multi-agent with the environment simply cloned n times and each agent acting "
+        "independently at every single timestep. The overall reward for this "
+        "experiment is then the sum over all individual agents' rewards.",
+    )
+
+    # Evaluation options.
+    parser.add_argument(
+        "--evaluation-num-env-runners",
+        type=int,
+        default=0,
+        help="The number of evaluation (remote) EnvRunners to use for the experiment.",
+    )
+    parser.add_argument(
+        "--evaluation-interval",
+        type=int,
+        default=0,
+        help="Every how many iterations to run one round of evaluation. "
+        "Use 0 (default) to disable evaluation.",
+    )
+    parser.add_argument(
+        "--evaluation-duration",
+        type=lambda v: v if v == "auto" else int(v),
+        default=10,
+        help="The number of evaluation units to run each evaluation round. "
+        "Use `--evaluation-duration-unit` to count either in 'episodes' "
+        "or 'timesteps'. If 'auto', will run as many as possible during train pass ("
+        "`--evaluation-parallel-to-training` must be set then).",
+    )
+    parser.add_argument(
+        "--evaluation-duration-unit",
+        type=str,
+        default="episodes",
+        choices=["episodes", "timesteps"],
+        help="The evaluation duration unit to count by. One of 'episodes' or "
+        "'timesteps'. This unit will be run `--evaluation-duration` times in each "
+        "evaluation round. If `--evaluation-duration=auto`, this setting does not "
+        "matter.",
+    )
+    parser.add_argument(
+        "--evaluation-parallel-to-training",
+        action="store_true",
+        help="Whether to run evaluation parallel to training. This might help speed up "
+        "your overall iteration time. Be aware that when using this option, your "
+        "reported evaluation results are referring to one iteration before the current "
+        "one.",
+    )
+
+    # RLlib logging options.
+    parser.add_argument(
+        "--output",
+        type=str,
+        default=None,
+        help="The output directory to write trajectories to, which are collected by "
+        "the algo's EnvRunners.",
+    )
+    parser.add_argument(
+        "--log-level",
+        type=str,
+        default=None,  # None -> use default
+        choices=["INFO", "DEBUG", "WARN", "ERROR"],
+        help="The log-level to be used by the RLlib logger.",
+    )
+
+    # tune.Tuner options.
+    parser.add_argument(
+        "--no-tune",
+        action="store_true",
+        help="Whether to NOT use tune.Tuner(), but rather a simple for-loop calling "
+        "`algo.train()` repeatedly until one of the stop criteria is met.",
+    )
+    parser.add_argument(
+        "--num-samples",
+        type=int,
+        default=1,
+        help="How many (tune.Tuner.fit()) experiments to execute - if possible in "
+        "parallel.",
+    )
+    parser.add_argument(
+        "--max-concurrent-trials",
+        type=int,
+        default=None,
+        help="How many (tune.Tuner) trials to run concurrently.",
+    )
+    parser.add_argument(
+        "--verbose",
+        type=int,
+        default=2,
+        help="The verbosity level for the `tune.Tuner()` running the experiment.",
+    )
+    parser.add_argument(
+        "--checkpoint-freq",
+        type=int,
+        default=0,
+        help=(
+            "The frequency (in training iterations) with which to create checkpoints. "
+            "Note that if --wandb-key is provided, all checkpoints will "
+            "automatically be uploaded to WandB."
+        ),
+    )
+    parser.add_argument(
+        "--checkpoint-at-end",
+        action="store_true",
+        help=(
+            "Whether to create a checkpoint at the very end of the experiment. "
+            "Note that if --wandb-key is provided, all checkpoints will "
+            "automatically be uploaded to WandB."
+        ),
+    )
+
+    # WandB logging options.
+    parser.add_argument(
+        "--wandb-key",
+        type=str,
+        default=None,
+        help="The WandB API key to use for uploading results.",
+    )
+    parser.add_argument(
+        "--wandb-project",
+        type=str,
+        default=None,
+        help="The WandB project name to use.",
+    )
+    parser.add_argument(
+        "--wandb-run-name",
+        type=str,
+        default=None,
+        help="The WandB run name to use.",
+    )
+
+    # Experiment stopping and testing criteria.
+    parser.add_argument(
+        "--stop-reward",
+        type=float,
+        default=default_reward,
+        help="Reward at which the script should stop training.",
+    )
+    parser.add_argument(
+        "--stop-iters",
+        type=int,
+        default=default_iters,
+        help="The number of iterations to train.",
+    )
+    parser.add_argument(
+        "--stop-timesteps",
+        type=int,
+        default=default_timesteps,
+        help="The number of (environment sampling) timesteps to train.",
+    )
+    parser.add_argument(
+        "--as-test",
+        action="store_true",
+        help="Whether this script should be run as a test. If set, --stop-reward must "
+        "be achieved within --stop-timesteps AND --stop-iters, otherwise this "
+        "script will throw an exception at the end.",
+    )
+    parser.add_argument(
+        "--as-release-test",
+        action="store_true",
+        help="Whether this script should be run as a release test. If set, "
+        "all that applies to the --as-test option is true, plus, a short JSON summary "
+        "will be written into a results file whose location is given by the ENV "
+        "variable `TEST_OUTPUT_JSON`.",
+    )
+
+    # Learner scaling options.
+    parser.add_argument(
+        "--num-learners",
+        type=int,
+        default=None,
+        help="The number of Learners to use. If none, use the algorithm's default "
+        "value.",
+    )
+    parser.add_argument(
+        "--num-gpus-per-learner",
+        type=float,
+        default=None,
+        help="The number of GPUs per Learner to use. If none and there are enough GPUs "
+        "for all required Learners (--num-learners), use a value of 1, otherwise 0.",
+    )
+
+    # Ray init options.
+    parser.add_argument("--num-cpus", type=int, default=0)
+    parser.add_argument(
+        "--local-mode",
+        action="store_true",
+        help="Init Ray in local mode for easier debugging.",
+    )
+
+    # Old API stack: config.num_gpus.
+    parser.add_argument(
+        "--num-gpus",
+        type=int,
+        default=0,
+        help="The number of GPUs to use (if on the old API stack).",
+    )
+
+    return parser
+
+
+def check(x, y, decimals=5, atol=None, rtol=None, false=False):
+    """
+    Checks two structures (dict, tuple, list,
+    np.array, float, int, etc..) for (almost) numeric identity.
+    All numbers in the two structures have to match up to `decimal` digits
+    after the floating point. Uses assertions.
+
+    Args:
+        x: The value to be compared (to the expectation: `y`). This
+            may be a Tensor.
+        y: The expected value to be compared to `x`. This must not
+            be a tf-Tensor, but may be a tf/torch-Tensor.
+        decimals: The number of digits after the floating point up to
+            which all numeric values have to match.
+        atol: Absolute tolerance of the difference between x and y
+            (overrides `decimals` if given).
+        rtol: Relative tolerance of the difference between x and y
+            (overrides `decimals` if given).
+        false: Whether to check that x and y are NOT the same.
+    """
+    # A dict type.
+    if isinstance(x, dict):
+        assert isinstance(y, dict), "ERROR: If x is dict, y needs to be a dict as well!"
+        y_keys = set(x.keys())
+        for key, value in x.items():
+            assert key in y, f"ERROR: y does not have x's key='{key}'! y={y}"
+            check(value, y[key], decimals=decimals, atol=atol, rtol=rtol, false=false)
+            y_keys.remove(key)
+        assert not y_keys, "ERROR: y contains keys ({}) that are not in x! y={}".format(
+            list(y_keys), y
+        )
+    # A tuple type.
+    elif isinstance(x, (tuple, list)):
+        assert isinstance(
+            y, (tuple, list)
+        ), "ERROR: If x is tuple/list, y needs to be a tuple/list as well!"
+        assert len(y) == len(
+            x
+        ), "ERROR: y does not have the same length as x ({} vs {})!".format(
+            len(y), len(x)
+        )
+        for i, value in enumerate(x):
+            check(value, y[i], decimals=decimals, atol=atol, rtol=rtol, false=false)
+    # Boolean comparison.
+    elif isinstance(x, (np.bool_, bool)):
+        if false is True:
+            assert bool(x) is not bool(y), f"ERROR: x ({x}) is y ({y})!"
+        else:
+            assert bool(x) is bool(y), f"ERROR: x ({x}) is not y ({y})!"
+    # Nones or primitives (excluding int vs float, which should be compared with
+    # tolerance/decimals as well).
+    elif (
+        x is None
+        or y is None
+        or isinstance(x, str)
+        or (isinstance(x, int) and isinstance(y, int))
+    ):
+        if false is True:
+            assert x != y, f"ERROR: x ({x}) is the same as y ({y})!"
+        else:
+            assert x == y, f"ERROR: x ({x}) is not the same as y ({y})!"
+    # String/byte comparisons.
+    elif (
+        hasattr(x, "dtype") and (x.dtype == object or str(x.dtype).startswith("<U"))
+    ) or isinstance(x, bytes):
+        try:
+            np.testing.assert_array_equal(x, y)
+            if false is True:
+                assert False, f"ERROR: x ({x}) is the same as y ({y})!"
+        except AssertionError as e:
+            if false is False:
+                raise e
+    # Everything else (assume numeric or tf/torch.Tensor).
+    # Also includes int vs float comparison, which is performed with tolerance/decimals.
+    else:
+        if tf1 is not None:
+            # y should never be a Tensor (y=expected value).
+            if isinstance(y, (tf1.Tensor, tf1.Variable)):
+                # In eager mode, numpyize tensors.
+                if tf.executing_eagerly():
+                    y = y.numpy()
+                else:
+                    raise ValueError(
+                        "`y` (expected value) must not be a Tensor. "
+                        "Use numpy.ndarray instead"
+                    )
+            if isinstance(x, (tf1.Tensor, tf1.Variable)):
+                # In eager mode, numpyize tensors.
+                if tf1.executing_eagerly():
+                    x = x.numpy()
+                # Otherwise, use a new tf-session.
+                else:
+                    with tf1.Session() as sess:
+                        x = sess.run(x)
+                        return check(
+                            x, y, decimals=decimals, atol=atol, rtol=rtol, false=false
+                        )
+        if torch is not None:
+            if isinstance(x, torch.Tensor):
+                x = x.detach().cpu().numpy()
+            if isinstance(y, torch.Tensor):
+                y = y.detach().cpu().numpy()
+
+        # Stats objects.
+        from ray.rllib.utils.metrics.stats import Stats
+
+        if isinstance(x, Stats):
+            x = x.peek()
+        if isinstance(y, Stats):
+            y = y.peek()
+
+        # Using decimals.
+        if atol is None and rtol is None:
+            # Assert equality of both values.
+            try:
+                np.testing.assert_almost_equal(x, y, decimal=decimals)
+            # Both values are not equal.
+            except AssertionError as e:
+                # Raise error in normal case.
+                if false is False:
+                    raise e
+            # Both values are equal.
+            else:
+                # If false is set -> raise error (not expected to be equal).
+                if false is True:
+                    assert False, f"ERROR: x ({x}) is the same as y ({y})!"
+
+        # Using atol/rtol.
+        else:
+            # Provide defaults for either one of atol/rtol.
+            if atol is None:
+                atol = 0
+            if rtol is None:
+                rtol = 1e-7
+            try:
+                np.testing.assert_allclose(x, y, atol=atol, rtol=rtol)
+            except AssertionError as e:
+                if false is False:
+                    raise e
+            else:
+                if false is True:
+                    assert False, f"ERROR: x ({x}) is the same as y ({y})!"
+
+
+def check_compute_single_action(
+    algorithm, include_state=False, include_prev_action_reward=False
+):
+    """Tests different combinations of args for algorithm.compute_single_action.
+
+    Args:
+        algorithm: The Algorithm object to test.
+        include_state: Whether to include the initial state of the Policy's
+            Model in the `compute_single_action` call.
+        include_prev_action_reward: Whether to include the prev-action and
+            -reward in the `compute_single_action` call.
+
+    Raises:
+        ValueError: If anything unexpected happens.
+    """
+    # Have to import this here to avoid circular dependency.
+    from ray.rllib.policy.sample_batch import DEFAULT_POLICY_ID, SampleBatch
+
+    # Some Algorithms may not abide to the standard API.
+    pid = DEFAULT_POLICY_ID
+    try:
+        # Multi-agent: Pick any learnable policy (or DEFAULT_POLICY if it's the only
+        # one).
+        pid = next(iter(algorithm.env_runner.get_policies_to_train()))
+        pol = algorithm.get_policy(pid)
+    except AttributeError:
+        pol = algorithm.policy
+    # Get the policy's model.
+    model = pol.model
+
+    action_space = pol.action_space
+
+    def _test(
+        what, method_to_test, obs_space, full_fetch, explore, timestep, unsquash, clip
+    ):
+        call_kwargs = {}
+        if what is algorithm:
+            call_kwargs["full_fetch"] = full_fetch
+            call_kwargs["policy_id"] = pid
+
+        obs = obs_space.sample()
+        if isinstance(obs_space, Box):
+            obs = np.clip(obs, -1.0, 1.0)
+        state_in = None
+        if include_state:
+            state_in = model.get_initial_state()
+            if not state_in:
+                state_in = []
+                i = 0
+                while f"state_in_{i}" in model.view_requirements:
+                    state_in.append(
+                        model.view_requirements[f"state_in_{i}"].space.sample()
+                    )
+                    i += 1
+        action_in = action_space.sample() if include_prev_action_reward else None
+        reward_in = 1.0 if include_prev_action_reward else None
+
+        if method_to_test == "input_dict":
+            assert what is pol
+
+            input_dict = {SampleBatch.OBS: obs}
+            if include_prev_action_reward:
+                input_dict[SampleBatch.PREV_ACTIONS] = action_in
+                input_dict[SampleBatch.PREV_REWARDS] = reward_in
+            if state_in:
+                if what.config.get("enable_rl_module_and_learner", False):
+                    input_dict["state_in"] = state_in
+                else:
+                    for i, s in enumerate(state_in):
+                        input_dict[f"state_in_{i}"] = s
+            input_dict_batched = SampleBatch(
+                tree.map_structure(lambda s: np.expand_dims(s, 0), input_dict)
+            )
+            action = pol.compute_actions_from_input_dict(
+                input_dict=input_dict_batched,
+                explore=explore,
+                timestep=timestep,
+                **call_kwargs,
+            )
+            # Unbatch everything to be able to compare against single
+            # action below.
+            # ARS and ES return action batches as lists.
+            if isinstance(action[0], list):
+                action = (np.array(action[0]), action[1], action[2])
+            action = tree.map_structure(lambda s: s[0], action)
+
+            try:
+                action2 = pol.compute_single_action(
+                    input_dict=input_dict,
+                    explore=explore,
+                    timestep=timestep,
+                    **call_kwargs,
+                )
+                # Make sure these are the same, unless we have exploration
+                # switched on (or noisy layers).
+                if not explore and not pol.config.get("noisy"):
+                    check(action, action2)
+            except TypeError:
+                pass
+        else:
+            action = what.compute_single_action(
+                obs,
+                state_in,
+                prev_action=action_in,
+                prev_reward=reward_in,
+                explore=explore,
+                timestep=timestep,
+                unsquash_action=unsquash,
+                clip_action=clip,
+                **call_kwargs,
+            )
+
+        state_out = None
+        if state_in or full_fetch or what is pol:
+            action, state_out, _ = action
+        if state_out:
+            for si, so in zip(tree.flatten(state_in), tree.flatten(state_out)):
+                if tf.is_tensor(si):
+                    # If si is a tensor of Dimensions, we need to convert it
+                    # We expect this to be the case for TF RLModules who's initial
+                    # states are Tf Tensors.
+                    si_shape = si.shape.as_list()
+                else:
+                    si_shape = list(si.shape)
+                check(si_shape, so.shape)
+
+        if unsquash is None:
+            unsquash = what.config["normalize_actions"]
+        if clip is None:
+            clip = what.config["clip_actions"]
+
+        # Test whether unsquash/clipping works on the Algorithm's
+        # compute_single_action method: Both flags should force the action
+        # to be within the space's bounds.
+        if method_to_test == "single" and what == algorithm:
+            if not action_space.contains(action) and (
+                clip or unsquash or not isinstance(action_space, Box)
+            ):
+                raise ValueError(
+                    f"Returned action ({action}) of algorithm/policy {what} "
+                    f"not in Env's action_space {action_space}"
+                )
+            # We are operating in normalized space: Expect only smaller action
+            # values.
+            if (
+                isinstance(action_space, Box)
+                and not unsquash
+                and what.config.get("normalize_actions")
+                and np.any(np.abs(action) > 15.0)
+            ):
+                raise ValueError(
+                    f"Returned action ({action}) of algorithm/policy {what} "
+                    "should be in normalized space, but seems too large/small "
+                    "for that!"
+                )
+
+    # Loop through: Policy vs Algorithm; Different API methods to calculate
+    # actions; unsquash option; clip option; full fetch or not.
+    for what in [pol, algorithm]:
+        if what is algorithm:
+            # Get the obs-space from Workers.env (not Policy) due to possible
+            # pre-processor up front.
+            worker_set = getattr(algorithm, "env_runner_group", None)
+            assert worker_set
+            if not worker_set.local_env_runner:
+                obs_space = algorithm.get_policy(pid).observation_space
+            else:
+                obs_space = worker_set.local_env_runner.for_policy(
+                    lambda p: p.observation_space, policy_id=pid
+                )
+            obs_space = getattr(obs_space, "original_space", obs_space)
+        else:
+            obs_space = pol.observation_space
+
+        for method_to_test in ["single"] + (["input_dict"] if what is pol else []):
+            for explore in [True, False]:
+                for full_fetch in [False, True] if what is algorithm else [False]:
+                    timestep = random.randint(0, 100000)
+                    for unsquash in [True, False, None]:
+                        for clip in [False] if unsquash else [True, False, None]:
+                            print("-" * 80)
+                            print(f"what={what}")
+                            print(f"method_to_test={method_to_test}")
+                            print(f"explore={explore}")
+                            print(f"full_fetch={full_fetch}")
+                            print(f"unsquash={unsquash}")
+                            print(f"clip={clip}")
+                            _test(
+                                what,
+                                method_to_test,
+                                obs_space,
+                                full_fetch,
+                                explore,
+                                timestep,
+                                unsquash,
+                                clip,
+                            )
+
+
+def check_inference_w_connectors(policy, env_name, max_steps: int = 100):
+    """Checks whether the given policy can infer actions from an env with connectors.
+
+    Args:
+        policy: The policy to check.
+        env_name: Name of the environment to check
+        max_steps: The maximum number of steps to run the environment for.
+
+    Raises:
+        ValueError: If the policy cannot infer actions from the environment.
+    """
+    # Avoids circular import
+    from ray.rllib.utils.policy import local_policy_inference
+
+    env = gym.make(env_name)
+
+    # Potentially wrap the env like we do in RolloutWorker
+    if is_atari(env):
+        env = wrap_deepmind(
+            env,
+            dim=policy.config["model"]["dim"],
+            framestack=policy.config["model"].get("framestack"),
+        )
+
+    obs, info = env.reset()
+    reward, terminated, truncated = 0.0, False, False
+    ts = 0
+    while not terminated and not truncated and ts < max_steps:
+        action_out = local_policy_inference(
+            policy,
+            env_id=0,
+            agent_id=0,
+            obs=obs,
+            reward=reward,
+            terminated=terminated,
+            truncated=truncated,
+            info=info,
+        )
+        obs, reward, terminated, truncated, info = env.step(action_out[0][0])
+
+        ts += 1
+
+
+def check_learning_achieved(
+    tune_results: "tune.ResultGrid",
+    min_value: float,
+    evaluation: Optional[bool] = None,
+    metric: str = f"{ENV_RUNNER_RESULTS}/episode_return_mean",
+):
+    """Throws an error if `min_reward` is not reached within tune_results.
+
+    Checks the last iteration found in tune_results for its
+    "episode_return_mean" value and compares it to `min_reward`.
+
+    Args:
+        tune_results: The tune.Tuner().fit() returned results object.
+        min_reward: The min reward that must be reached.
+        evaluation: If True, use `evaluation/env_runners/[metric]`, if False, use
+            `env_runners/[metric]`, if None, use evaluation sampler results if
+            available otherwise, use train sampler results.
+
+    Raises:
+        ValueError: If `min_reward` not reached.
+    """
+    # Get maximum value of `metrics` over all trials
+    # (check if at least one trial achieved some learning, not just the final one).
+    recorded_values = []
+    for _, row in tune_results.get_dataframe().iterrows():
+        if evaluation or (
+            evaluation is None and f"{EVALUATION_RESULTS}/{metric}" in row
+        ):
+            recorded_values.append(row[f"{EVALUATION_RESULTS}/{metric}"])
+        else:
+            recorded_values.append(row[metric])
+    best_value = max(recorded_values)
+    if best_value < min_value:
+        raise ValueError(f"`{metric}` of {min_value} not reached!")
+    print(f"`{metric}` of {min_value} reached! ok")
+
+
+def check_off_policyness(
+    results: ResultDict,
+    upper_limit: float,
+    lower_limit: float = 0.0,
+) -> Optional[float]:
+    """Verifies that the off-policy'ness of some update is within some range.
+
+    Off-policy'ness is defined as the average (across n workers) diff
+    between the number of gradient updates performed on the policy used
+    for sampling vs the number of gradient updates that have been performed
+    on the trained policy (usually the one on the local worker).
+
+    Uses the published DIFF_NUM_GRAD_UPDATES_VS_SAMPLER_POLICY metric inside
+    a training results dict and compares to the given bounds.
+
+    Note: Only works with single-agent results thus far.
+
+    Args:
+        results: The training results dict.
+        upper_limit: The upper limit to for the off_policy_ness value.
+        lower_limit: The lower limit to for the off_policy_ness value.
+
+    Returns:
+        The off-policy'ness value (described above).
+
+    Raises:
+        AssertionError: If the value is out of bounds.
+    """
+
+    # Have to import this here to avoid circular dependency.
+    from ray.rllib.policy.sample_batch import DEFAULT_POLICY_ID
+    from ray.rllib.utils.metrics.learner_info import LEARNER_INFO
+
+    # Assert that the off-policy'ness is within the given bounds.
+    learner_info = results["info"][LEARNER_INFO]
+    if DEFAULT_POLICY_ID not in learner_info:
+        return None
+    off_policy_ness = learner_info[DEFAULT_POLICY_ID][
+        DIFF_NUM_GRAD_UPDATES_VS_SAMPLER_POLICY
+    ]
+    # Roughly: Reaches up to 0.4 for 2 rollout workers and up to 0.2 for
+    # 1 rollout worker.
+    if not (lower_limit <= off_policy_ness <= upper_limit):
+        raise AssertionError(
+            f"`off_policy_ness` ({off_policy_ness}) is outside the given bounds "
+            f"({lower_limit} - {upper_limit})!"
+        )
+
+    return off_policy_ness
+
+
+def check_train_results_new_api_stack(train_results: ResultDict) -> None:
+    """Checks proper structure of a Algorithm.train() returned dict.
+
+    Args:
+        train_results: The train results dict to check.
+
+    Raises:
+        AssertionError: If `train_results` doesn't have the proper structure or
+            data in it.
+    """
+    # Import these here to avoid circular dependencies.
+    from ray.rllib.utils.metrics import (
+        ENV_RUNNER_RESULTS,
+        FAULT_TOLERANCE_STATS,
+        LEARNER_RESULTS,
+        TIMERS,
+    )
+
+    # Assert that some keys are where we would expect them.
+    for key in [
+        ENV_RUNNER_RESULTS,
+        FAULT_TOLERANCE_STATS,
+        LEARNER_RESULTS,
+        TIMERS,
+        TRAINING_ITERATION,
+        "config",
+    ]:
+        assert (
+            key in train_results
+        ), f"'{key}' not found in `train_results` ({train_results})!"
+
+    # Make sure, `config` is an actual dict, not an AlgorithmConfig object.
+    assert isinstance(
+        train_results["config"], dict
+    ), "`config` in results not a python dict!"
+
+    from ray.rllib.algorithms.algorithm_config import AlgorithmConfig
+
+    is_multi_agent = (
+        AlgorithmConfig()
+        .update_from_dict({"policies": train_results["config"]["policies"]})
+        .is_multi_agent()
+    )
+
+    # Check in particular the "info" dict.
+    learner_results = train_results[LEARNER_RESULTS]
+
+    # Make sure we have a `DEFAULT_MODULE_ID key if we are not in a
+    # multi-agent setup.
+    if not is_multi_agent:
+        assert len(learner_results) == 0 or DEFAULT_MODULE_ID in learner_results, (
+            f"'{DEFAULT_MODULE_ID}' not found in "
+            f"train_results['{LEARNER_RESULTS}']!"
+        )
+
+    for module_id, module_metrics in learner_results.items():
+        # The ModuleID can be __all_modules__ in multi-agent case when the new learner
+        # stack is enabled.
+        if module_id == "__all_modules__":
+            continue
+
+        # On the new API stack, policy has no LEARNER_STATS_KEY under it anymore.
+        for key, value in module_metrics.items():
+            # Min- and max-stats should be single values.
+            if key.endswith("_min") or key.endswith("_max"):
+                assert np.isscalar(value), f"'key' value not a scalar ({value})!"
+
+    return train_results
+
+
+@OldAPIStack
+def check_train_results(train_results: ResultDict):
+    """Checks proper structure of a Algorithm.train() returned dict.
+
+    Args:
+        train_results: The train results dict to check.
+
+    Raises:
+        AssertionError: If `train_results` doesn't have the proper structure or
+            data in it.
+    """
+    # Import these here to avoid circular dependencies.
+    from ray.rllib.policy.sample_batch import DEFAULT_POLICY_ID
+    from ray.rllib.utils.metrics.learner_info import LEARNER_INFO, LEARNER_STATS_KEY
+
+    # Assert that some keys are where we would expect them.
+    for key in [
+        "config",
+        "custom_metrics",
+        ENV_RUNNER_RESULTS,
+        "info",
+        "iterations_since_restore",
+        "num_healthy_workers",
+        "perf",
+        "time_since_restore",
+        "time_this_iter_s",
+        "timers",
+        "time_total_s",
+        TRAINING_ITERATION,
+    ]:
+        assert (
+            key in train_results
+        ), f"'{key}' not found in `train_results` ({train_results})!"
+
+    for key in [
+        "episode_len_mean",
+        "episode_reward_max",
+        "episode_reward_mean",
+        "episode_reward_min",
+        "hist_stats",
+        "policy_reward_max",
+        "policy_reward_mean",
+        "policy_reward_min",
+        "sampler_perf",
+    ]:
+        assert key in train_results[ENV_RUNNER_RESULTS], (
+            f"'{key}' not found in `train_results[ENV_RUNNER_RESULTS]` "
+            f"({train_results[ENV_RUNNER_RESULTS]})!"
+        )
+
+    # Make sure, `config` is an actual dict, not an AlgorithmConfig object.
+    assert isinstance(
+        train_results["config"], dict
+    ), "`config` in results not a python dict!"
+
+    from ray.rllib.algorithms.algorithm_config import AlgorithmConfig
+
+    is_multi_agent = (
+        AlgorithmConfig()
+        .update_from_dict({"policies": train_results["config"]["policies"]})
+        .is_multi_agent()
+    )
+
+    # Check in particular the "info" dict.
+    info = train_results["info"]
+    assert LEARNER_INFO in info, f"'learner' not in train_results['infos'] ({info})!"
+    assert (
+        "num_steps_trained" in info or NUM_ENV_STEPS_TRAINED in info
+    ), f"'num_(env_)?steps_trained' not in train_results['infos'] ({info})!"
+
+    learner_info = info[LEARNER_INFO]
+
+    # Make sure we have a default_policy key if we are not in a
+    # multi-agent setup.
+    if not is_multi_agent:
+        # APEX algos sometimes have an empty learner info dict (no metrics
+        # collected yet).
+        assert len(learner_info) == 0 or DEFAULT_POLICY_ID in learner_info, (
+            f"'{DEFAULT_POLICY_ID}' not found in "
+            f"train_results['infos']['learner'] ({learner_info})!"
+        )
+
+    for pid, policy_stats in learner_info.items():
+        if pid == "batch_count":
+            continue
+
+        # the pid can be __all__ in multi-agent case when the new learner stack is
+        # enabled.
+        if pid == "__all__":
+            continue
+
+        # On the new API stack, policy has no LEARNER_STATS_KEY under it anymore.
+        if LEARNER_STATS_KEY in policy_stats:
+            learner_stats = policy_stats[LEARNER_STATS_KEY]
+        else:
+            learner_stats = policy_stats
+        for key, value in learner_stats.items():
+            # Min- and max-stats should be single values.
+            if key.startswith("min_") or key.startswith("max_"):
+                assert np.isscalar(value), f"'key' value not a scalar ({value})!"
+
+    return train_results
+
+
+# TODO (sven): Make this the de-facto, well documented, and unified utility for most of
+#  our tests:
+#  - CI (label: "learning_tests")
+#  - release tests (benchmarks)
+#  - example scripts
+def run_rllib_example_script_experiment(
+    base_config: "AlgorithmConfig",
+    args: Optional[argparse.Namespace] = None,
+    *,
+    stop: Optional[Dict] = None,
+    success_metric: Optional[Dict] = None,
+    trainable: Optional[Type] = None,
+    tune_callbacks: Optional[List] = None,
+    keep_config: bool = False,
+    scheduler=None,
+    progress_reporter=None,
+) -> Union[ResultDict, tune.result_grid.ResultGrid]:
+    """Given an algorithm config and some command line args, runs an experiment.
+
+    There are some constraints on what properties must be defined in `args`.
+    It should ideally be generated via calling
+    `args = add_rllib_example_script_args()`, which can be found in this very module
+    here.
+
+    The function sets up an Algorithm object from the given config (altered by the
+    contents of `args`), then runs the Algorithm via Tune (or manually, if
+    `args.no_tune` is set to True) using the stopping criteria in `stop`.
+
+    At the end of the experiment, if `args.as_test` is True, checks, whether the
+    Algorithm reached the `success_metric` (if None, use `env_runners/
+    episode_return_mean` with a minimum value of `args.stop_reward`).
+
+    See https://github.com/ray-project/ray/tree/master/rllib/examples for an overview
+    of all supported command line options.
+
+    Args:
+        base_config: The AlgorithmConfig object to use for this experiment. This base
+            config will be automatically "extended" based on some of the provided
+            `args`. For example, `args.num_env_runners` is used to set
+            `config.num_env_runners`, etc..
+        args: A argparse.Namespace object, ideally returned by calling
+            `args = add_rllib_example_script_args()`. It must have the following
+            properties defined: `stop_iters`, `stop_reward`, `stop_timesteps`,
+            `no_tune`, `verbose`, `checkpoint_freq`, `as_test`. Optionally, for WandB
+            logging: `wandb_key`, `wandb_project`, `wandb_run_name`.
+        stop: An optional dict mapping ResultDict key strings (using "/" in case of
+            nesting, e.g. "env_runners/episode_return_mean" for referring to
+            `result_dict['env_runners']['episode_return_mean']` to minimum
+            values, reaching of which will stop the experiment). Default is:
+            {
+            "env_runners/episode_return_mean": args.stop_reward,
+            "training_iteration": args.stop_iters,
+            "num_env_steps_sampled_lifetime": args.stop_timesteps,
+            }
+        success_metric: Only relevant if `args.as_test` is True.
+            A dict mapping a single(!) ResultDict key string (using "/" in
+            case of nesting, e.g. "env_runners/episode_return_mean" for referring
+            to `result_dict['env_runners']['episode_return_mean']` to a single(!)
+            minimum value to be reached in order for the experiment to count as
+            successful. If `args.as_test` is True AND this `success_metric` is not
+            reached with the bounds defined by `stop`, will raise an Exception.
+        trainable: The Trainable sub-class to run in the tune.Tuner. If None (default),
+            use the registered RLlib Algorithm class specified by args.algo.
+        tune_callbacks: A list of Tune callbacks to configure with the tune.Tuner.
+            In case `args.wandb_key` is provided, appends a WandB logger to this
+            list.
+        keep_config: Set this to True, if you don't want this utility to change the
+            given `base_config` in any way and leave it as-is. This is helpful
+            for those example scripts which demonstrate how to set config settings
+            that are taken care of automatically in this function otherwise (e.g.
+            `num_env_runners`).
+
+    Returns:
+        The last ResultDict from a --no-tune run OR the tune.Tuner.fit()
+        results.
+    """
+    if args is None:
+        parser = add_rllib_example_script_args()
+        args = parser.parse_args()
+
+    # If run --as-release-test, --as-test must also be set.
+    if args.as_release_test:
+        args.as_test = True
+
+    # Initialize Ray.
+    ray.init(
+        num_cpus=args.num_cpus or None,
+        local_mode=args.local_mode,
+        ignore_reinit_error=True,
+    )
+
+    # Define one or more stopping criteria.
+    if stop is None:
+        stop = {
+            f"{ENV_RUNNER_RESULTS}/{EPISODE_RETURN_MEAN}": args.stop_reward,
+            f"{ENV_RUNNER_RESULTS}/{NUM_ENV_STEPS_SAMPLED_LIFETIME}": (
+                args.stop_timesteps
+            ),
+            TRAINING_ITERATION: args.stop_iters,
+        }
+
+    config = base_config
+
+    # Enhance the `base_config`, based on provided `args`.
+    if not keep_config:
+        # Set the framework.
+        config.framework(args.framework)
+
+        # Add an env specifier (only if not already set in config)?
+        if args.env is not None and config.env is None:
+            config.environment(args.env)
+
+        # Enable the new API stack?
+        if args.enable_new_api_stack:
+            config.api_stack(
+                enable_rl_module_and_learner=True,
+                enable_env_runner_and_connector_v2=True,
+            )
+
+        # Define EnvRunner/RolloutWorker scaling and behavior.
+        if args.num_env_runners is not None:
+            config.env_runners(num_env_runners=args.num_env_runners)
+
+        # Define compute resources used automatically (only using the --num-learners
+        # and --num-gpus-per-learner args).
+        # New stack.
+        if config.enable_rl_module_and_learner:
+            if args.num_gpus > 0:
+                raise ValueError(
+                    "--num-gpus is not supported on the new API stack! To train on "
+                    "GPUs, use the command line options `--num-gpus-per-learner=1` and "
+                    "`--num-learners=[your number of available GPUs]`, instead."
+                )
+
+            # Do we have GPUs available in the cluster?
+            num_gpus_available = ray.cluster_resources().get("GPU", 0)
+            # Number of actual Learner instances (including the local Learner if
+            # `num_learners=0`).
+            num_actual_learners = (
+                args.num_learners
+                if args.num_learners is not None
+                else config.num_learners
+            ) or 1  # 1: There is always a local Learner, if num_learners=0.
+            # How many were hard-requested by the user
+            # (through explicit `--num-gpus-per-learner >= 1`).
+            num_gpus_requested = (args.num_gpus_per_learner or 0) * num_actual_learners
+            # Number of GPUs needed, if `num_gpus_per_learner=None` (auto).
+            num_gpus_needed_if_available = (
+                args.num_gpus_per_learner
+                if args.num_gpus_per_learner is not None
+                else 1
+            ) * num_actual_learners
+            # Define compute resources used.
+            config.resources(num_gpus=0)  # old API stack setting
+            if args.num_learners is not None:
+                config.learners(num_learners=args.num_learners)
+
+            # User wants to use GPUs if available, but doesn't hard-require them.
+            if args.num_gpus_per_learner is None:
+                if num_gpus_available >= num_gpus_needed_if_available:
+                    config.learners(num_gpus_per_learner=1)
+                else:
+                    config.learners(num_gpus_per_learner=0, num_cpus_per_learner=1)
+
+            # User hard-requires n GPUs, but they are not available -> Error.
+            elif num_gpus_available < num_gpus_requested:
+                raise ValueError(
+                    "You are running your script with --num-learners="
+                    f"{args.num_learners} and --num-gpus-per-learner="
+                    f"{args.num_gpus_per_learner}, but your cluster only has "
+                    f"{num_gpus_available} GPUs! Will run "
+                    f"with {num_gpus_available} CPU Learners instead."
+                )
+
+            # All required GPUs are available -> Use them.
+            else:
+                config.learners(num_gpus_per_learner=args.num_gpus_per_learner)
+
+        # Old stack.
+        else:
+            config.resources(num_gpus=args.num_gpus)
+
+        # Evaluation setup.
+        if args.evaluation_interval > 0:
+            config.evaluation(
+                evaluation_num_env_runners=args.evaluation_num_env_runners,
+                evaluation_interval=args.evaluation_interval,
+                evaluation_duration=args.evaluation_duration,
+                evaluation_duration_unit=args.evaluation_duration_unit,
+                evaluation_parallel_to_training=args.evaluation_parallel_to_training,
+            )
+
+        # Set the log-level (if applicable).
+        if args.log_level is not None:
+            config.debugging(log_level=args.log_level)
+
+        # Set the output dir (if applicable).
+        if args.output is not None:
+            config.offline_data(output=args.output)
+
+    # Run the experiment w/o Tune (directly operate on the RLlib Algorithm object).
+    if args.no_tune:
+        assert not args.as_test and not args.as_release_test
+        algo = config.build()
+        for i in range(stop.get(TRAINING_ITERATION, args.stop_iters)):
+            results = algo.train()
+            if ENV_RUNNER_RESULTS in results:
+                mean_return = results[ENV_RUNNER_RESULTS].get(
+                    EPISODE_RETURN_MEAN, np.nan
+                )
+                print(f"iter={i} R={mean_return}", end="")
+            if EVALUATION_RESULTS in results:
+                Reval = results[EVALUATION_RESULTS][ENV_RUNNER_RESULTS][
+                    EPISODE_RETURN_MEAN
+                ]
+                print(f" R(eval)={Reval}", end="")
+            print()
+            for key, threshold in stop.items():
+                val = results
+                for k in key.split("/"):
+                    try:
+                        val = val[k]
+                    except KeyError:
+                        val = None
+                        break
+                if val is not None and not np.isnan(val) and val >= threshold:
+                    print(f"Stop criterium ({key}={threshold}) fulfilled!")
+                    ray.shutdown()
+                    return results
+
+        ray.shutdown()
+        return results
+
+    # Run the experiment using Ray Tune.
+
+    # Log results using WandB.
+    tune_callbacks = tune_callbacks or []
+    if hasattr(args, "wandb_key") and (
+        args.wandb_key is not None or WANDB_ENV_VAR in os.environ
+    ):
+        wandb_key = args.wandb_key or os.environ[WANDB_ENV_VAR]
+        project = args.wandb_project or (
+            args.algo.lower() + "-" + re.sub("\\W+", "-", str(config.env).lower())
+        )
+        tune_callbacks.append(
+            WandbLoggerCallback(
+                api_key=wandb_key,
+                project=project,
+                upload_checkpoints=True,
+                **({"name": args.wandb_run_name} if args.wandb_run_name else {}),
+            )
+        )
+
+    # Auto-configure a CLIReporter (to log the results to the console).
+    # Use better ProgressReporter for multi-agent cases: List individual policy rewards.
+    if progress_reporter is None and args.num_agents > 0:
+        progress_reporter = CLIReporter(
+            metric_columns={
+                **{
+                    TRAINING_ITERATION: "iter",
+                    "time_total_s": "total time (s)",
+                    NUM_ENV_STEPS_SAMPLED_LIFETIME: "ts",
+                    f"{ENV_RUNNER_RESULTS}/{EPISODE_RETURN_MEAN}": "combined return",
+                },
+                **{
+                    (
+                        f"{ENV_RUNNER_RESULTS}/module_episode_returns_mean/" f"{pid}"
+                    ): f"return {pid}"
+                    for pid in config.policies
+                },
+            },
+        )
+
+    # Force Tuner to use old progress output as the new one silently ignores our custom
+    # `CLIReporter`.
+    os.environ["RAY_AIR_NEW_OUTPUT"] = "0"
+
+    # Run the actual experiment (using Tune).
+    start_time = time.time()
+    results = tune.Tuner(
+        trainable or config.algo_class,
+        param_space=config,
+        run_config=air.RunConfig(
+            stop=stop,
+            verbose=args.verbose,
+            callbacks=tune_callbacks,
+            checkpoint_config=air.CheckpointConfig(
+                checkpoint_frequency=args.checkpoint_freq,
+                checkpoint_at_end=args.checkpoint_at_end,
+            ),
+            progress_reporter=progress_reporter,
+        ),
+        tune_config=tune.TuneConfig(
+            num_samples=args.num_samples,
+            max_concurrent_trials=args.max_concurrent_trials,
+            scheduler=scheduler,
+        ),
+    ).fit()
+    time_taken = time.time() - start_time
+
+    ray.shutdown()
+
+    # If run as a test, check whether we reached the specified success criteria.
+    test_passed = False
+    if args.as_test:
+        # Success metric not provided, try extracting it from `stop`.
+        if success_metric is None:
+            for try_it in [
+                f"{EVALUATION_RESULTS}/{ENV_RUNNER_RESULTS}/{EPISODE_RETURN_MEAN}",
+                f"{ENV_RUNNER_RESULTS}/{EPISODE_RETURN_MEAN}",
+            ]:
+                if try_it in stop:
+                    success_metric = {try_it: stop[try_it]}
+                    break
+            if success_metric is None:
+                success_metric = {
+                    f"{ENV_RUNNER_RESULTS}/{EPISODE_RETURN_MEAN}": args.stop_reward,
+                }
+        # TODO (sven): Make this work for more than one metric (AND-logic?).
+        # Get maximum value of `metric` over all trials
+        # (check if at least one trial achieved some learning, not just the final one).
+        success_metric_key, success_metric_value = next(iter(success_metric.items()))
+        best_value = max(
+            row[success_metric_key] for _, row in results.get_dataframe().iterrows()
+        )
+        if best_value >= success_metric_value:
+            test_passed = True
+            print(f"`{success_metric_key}` of {success_metric_value} reached! ok")
+
+        if args.as_release_test:
+            trial = results._experiment_analysis.trials[0]
+            stats = trial.last_result
+            stats.pop("config", None)
+            json_summary = {
+                "time_taken": float(time_taken),
+                "trial_states": [trial.status],
+                "last_update": float(time.time()),
+                "stats": stats,
+                "passed": [test_passed],
+                "not_passed": [not test_passed],
+                "failures": {str(trial): 1} if not test_passed else {},
+            }
+            with open(
+                os.environ.get("TEST_OUTPUT_JSON", "/tmp/learning_test.json"),
+                "wt",
+            ) as f:
+                try:
+                    json.dump(json_summary, f)
+                # Something went wrong writing json. Try again w/ simplified stats.
+                except Exception:
+                    from ray.rllib.algorithms.algorithm import Algorithm
+
+                    simplified_stats = {
+                        k: stats[k] for k in Algorithm._progress_metrics if k in stats
+                    }
+                    json_summary["stats"] = simplified_stats
+                    json.dump(json_summary, f)
+
+        if not test_passed:
+            raise ValueError(
+                f"`{success_metric_key}` of {success_metric_value} not reached!"
+            )
+
+    return results
+
+
+def check_same_batch(batch1, batch2) -> None:
+    """Check if both batches are (almost) identical.
+
+    For MultiAgentBatches, the step count and individual policy's
+    SampleBatches are checked for identity. For SampleBatches, identity is
+    checked as the almost numerical key-value-pair identity between batches
+    with ray.rllib.utils.test_utils.check(). unroll_id is compared only if
+    both batches have an unroll_id.
+
+    Args:
+        batch1: Batch to compare against batch2
+        batch2: Batch to compare against batch1
+    """
+    # Avoids circular import
+    from ray.rllib.policy.sample_batch import MultiAgentBatch, SampleBatch
+
+    assert type(batch1) is type(
+        batch2
+    ), "Input batches are of different types {} and {}".format(
+        str(type(batch1)), str(type(batch2))
+    )
+
+    def check_sample_batches(_batch1, _batch2, _policy_id=None):
+        unroll_id_1 = _batch1.get("unroll_id", None)
+        unroll_id_2 = _batch2.get("unroll_id", None)
+        # unroll IDs only have to fit if both batches have them
+        if unroll_id_1 is not None and unroll_id_2 is not None:
+            assert unroll_id_1 == unroll_id_2
+
+        batch1_keys = set()
+        for k, v in _batch1.items():
+            # unroll_id is compared above already
+            if k == "unroll_id":
+                continue
+            check(v, _batch2[k])
+            batch1_keys.add(k)
+
+        batch2_keys = set(_batch2.keys())
+        # unroll_id is compared above already
+        batch2_keys.discard("unroll_id")
+        _difference = batch1_keys.symmetric_difference(batch2_keys)
+
+        # Cases where one batch has info and the other has not
+        if _policy_id:
+            assert not _difference, (
+                "SampleBatches for policy with ID {} "
+                "don't share information on the "
+                "following information: \n{}"
+                "".format(_policy_id, _difference)
+            )
+        else:
+            assert not _difference, (
+                "SampleBatches don't share information "
+                "on the following information: \n{}"
+                "".format(_difference)
+            )
+
+    if type(batch1) is SampleBatch:
+        check_sample_batches(batch1, batch2)
+    elif type(batch1) is MultiAgentBatch:
+        assert batch1.count == batch2.count
+        batch1_ids = set()
+        for policy_id, policy_batch in batch1.policy_batches.items():
+            check_sample_batches(
+                policy_batch, batch2.policy_batches[policy_id], policy_id
+            )
+            batch1_ids.add(policy_id)
+
+        # Case where one ma batch has info on a policy the other has not
+        batch2_ids = set(batch2.policy_batches.keys())
+        difference = batch1_ids.symmetric_difference(batch2_ids)
+        assert (
+            not difference
+        ), f"MultiAgentBatches don't share the following information: \n{difference}."
+    else:
+        raise ValueError("Unsupported batch type " + str(type(batch1)))
+
+
+def check_reproducibilty(
+    algo_class: Type["Algorithm"],
+    algo_config: "AlgorithmConfig",
+    *,
+    fw_kwargs: Dict[str, Any],
+    training_iteration: int = 1,
+) -> None:
+    # TODO @kourosh: we can get rid of examples/deterministic_training.py once
+    # this is added to all algorithms
+    """Check if the algorithm is reproducible across different testing conditions:
+
+        frameworks: all input frameworks
+        num_gpus: int(os.environ.get("RLLIB_NUM_GPUS", "0"))
+        num_workers: 0 (only local workers) or
+                     4 ((1) local workers + (4) remote workers)
+        num_envs_per_env_runner: 2
+
+    Args:
+        algo_class: Algorithm class to test.
+        algo_config: Base config to use for the algorithm.
+        fw_kwargs: Framework iterator keyword arguments.
+        training_iteration: Number of training iterations to run.
+
+    Returns:
+        None
+
+    Raises:
+        It raises an AssertionError if the algorithm is not reproducible.
+    """
+    from ray.rllib.policy.sample_batch import DEFAULT_POLICY_ID
+    from ray.rllib.utils.metrics.learner_info import LEARNER_INFO
+
+    stop_dict = {TRAINING_ITERATION: training_iteration}
+    # use 0 and 2 workers (for more that 4 workers we have to make sure the instance
+    # type in ci build has enough resources)
+    for num_workers in [0, 2]:
+        algo_config = (
+            algo_config.debugging(seed=42).env_runners(
+                num_env_runners=num_workers, num_envs_per_env_runner=2
+            )
+            # new API
+            .learners(
+                num_gpus_per_learner=int(os.environ.get("RLLIB_NUM_GPUS", "0")),
+            )
+            # old API
+            .resources(
+                num_gpus=int(os.environ.get("RLLIB_NUM_GPUS", "0")),
+            )
+        )
+
+        print(
+            f"Testing reproducibility of {algo_class.__name__}"
+            f" with {num_workers} workers"
+        )
+        print("/// config")
+        pprint.pprint(algo_config.to_dict())
+        # test tune.Tuner().fit() reproducibility
+        results1 = tune.Tuner(
+            algo_class,
+            param_space=algo_config.to_dict(),
+            run_config=air.RunConfig(stop=stop_dict, verbose=1),
+        ).fit()
+        results1 = results1.get_best_result().metrics
+
+        results2 = tune.Tuner(
+            algo_class,
+            param_space=algo_config.to_dict(),
+            run_config=air.RunConfig(stop=stop_dict, verbose=1),
+        ).fit()
+        results2 = results2.get_best_result().metrics
+
+        # Test rollout behavior.
+        check(
+            results1[ENV_RUNNER_RESULTS]["hist_stats"],
+            results2[ENV_RUNNER_RESULTS]["hist_stats"],
+        )
+        # As well as training behavior (minibatch sequence during SGD
+        # iterations).
+        # As well as training behavior (minibatch sequence during SGD
+        # iterations).
+        if algo_config.enable_rl_module_and_learner:
+            check(
+                results1["info"][LEARNER_INFO][DEFAULT_POLICY_ID],
+                results2["info"][LEARNER_INFO][DEFAULT_POLICY_ID],
+            )
+        else:
+            check(
+                results1["info"][LEARNER_INFO][DEFAULT_POLICY_ID]["learner_stats"],
+                results2["info"][LEARNER_INFO][DEFAULT_POLICY_ID]["learner_stats"],
+            )
+
+
+def get_cartpole_dataset_reader(batch_size: int = 1) -> "DatasetReader":
+    """Returns a DatasetReader for the cartpole dataset.
+    Args:
+        batch_size: The batch size to use for the reader.
+    Returns:
+        A rllib DatasetReader for the cartpole dataset.
+    """
+    from ray.rllib.algorithms import AlgorithmConfig
+    from ray.rllib.offline import IOContext
+    from ray.rllib.offline.dataset_reader import (
+        DatasetReader,
+        get_dataset_and_shards,
+    )
+
+    path = "tests/data/cartpole/large.json"
+    input_config = {"format": "json", "paths": path}
+    dataset, _ = get_dataset_and_shards(
+        AlgorithmConfig().offline_data(input_="dataset", input_config=input_config)
+    )
+    ioctx = IOContext(
+        config=(
+            AlgorithmConfig()
+            .training(train_batch_size=batch_size)
+            .offline_data(actions_in_input_normalized=True)
+        ),
+        worker_index=0,
+    )
+    reader = DatasetReader(dataset, ioctx)
+    return reader
+
+
+class ModelChecker:
+    """Helper class to compare architecturally identical Models across frameworks.
+
+    Holds a ModelConfig, such that individual models can be added simply via their
+    framework string (by building them with config.build(framework=...).
+    A call to `check()` forces all added models to be compared in terms of their
+    number of trainable and non-trainable parameters, as well as, their
+    computation results given a common weights structure and values and identical
+    inputs to the models.
+    """
+
+    def __init__(self, config):
+        self.config = config
+
+        # To compare number of params between frameworks.
+        self.param_counts = {}
+        # To compare computed outputs from fixed-weights-nets between frameworks.
+        self.output_values = {}
+
+        # We will pass an observation filled with this one random value through
+        # all DL networks (after they have been set to fixed-weights) to compare
+        # the computed outputs.
+        self.random_fill_input_value = np.random.uniform(-0.01, 0.01)
+
+        # Dict of models to check against each other.
+        self.models = {}
+
+    def add(self, framework: str = "torch", obs=True, state=False) -> Any:
+        """Builds a new Model for the given framework."""
+        model = self.models[framework] = self.config.build(framework=framework)
+
+        # Pass a B=1 observation through the model.
+        inputs = np.full(
+            [1] + ([1] if state else []) + list(self.config.input_dims),
+            self.random_fill_input_value,
+        )
+        if obs:
+            inputs = {Columns.OBS: inputs}
+        if state:
+            inputs[Columns.STATE_IN] = tree.map_structure(
+                lambda s: np.zeros(shape=[1] + list(s)), state
+            )
+        if framework == "torch":
+            from ray.rllib.utils.torch_utils import convert_to_torch_tensor
+
+            inputs = convert_to_torch_tensor(inputs)
+        # w/ old specs: inputs = model.input_specs.fill(self.random_fill_input_value)
+
+        outputs = model(inputs)
+
+        # Bring model into a reproducible, comparable state (so we can compare
+        # computations across frameworks). Use only a value-sequence of len=1 here
+        # as it could possibly be that the layers are stored in different order
+        # across the different frameworks.
+        model._set_to_dummy_weights(value_sequence=(self.random_fill_input_value,))
+
+        # Perform another forward pass.
+        comparable_outputs = model(inputs)
+
+        # Store the number of parameters for this framework's net.
+        self.param_counts[framework] = model.get_num_parameters()
+        # Store the fixed-weights-net outputs for this framework's net.
+        if framework == "torch":
+            self.output_values[framework] = tree.map_structure(
+                lambda s: s.detach().numpy() if s is not None else None,
+                comparable_outputs,
+            )
+        else:
+            self.output_values[framework] = tree.map_structure(
+                lambda s: s.numpy() if s is not None else None, comparable_outputs
+            )
+        return outputs
+
+    def check(self):
+        """Compares all added Models with each other and possibly raises errors."""
+
+        main_key = next(iter(self.models.keys()))
+        # Compare number of trainable and non-trainable params between all
+        # frameworks.
+        for c in self.param_counts.values():
+            check(c, self.param_counts[main_key])
+
+        # Compare dummy outputs by exact values given that all nets received the
+        # same input and all nets have the same (dummy) weight values.
+        for v in self.output_values.values():
+            check(v, self.output_values[main_key], atol=0.0005)
+
+
+def _get_mean_action_from_algorithm(alg: "Algorithm", obs: np.ndarray) -> np.ndarray:
+    """Returns the mean action computed by the given algorithm.
+
+    Note: This makes calls to `Algorithm.compute_single_action`
+
+    Args:
+        alg: The constructed algorithm to run inference on.
+        obs: The observation to compute the action for.
+
+    Returns:
+        The mean action computed by the algorithm over 5000 samples.
+
+    """
+    out = []
+    for _ in range(5000):
+        out.append(float(alg.compute_single_action(obs)))
+    return np.mean(out)
+
+
+def check_supported_spaces(
+    alg: str,
+    config: "AlgorithmConfig",
+    train: bool = True,
+    check_bounds: bool = False,
+    frameworks: Optional[Tuple[str]] = None,
+    use_gpu: bool = False,
+):
+    """Checks whether the given algorithm supports different action and obs spaces.
+
+        Performs the checks by constructing an rllib algorithm from the config and
+        checking to see that the model inside the policy is the correct one given
+        the action and obs spaces. For example if the action space is discrete and
+        the obs space is an image, then the model should be a vision network with
+        a categorical action distribution.
+
+    Args:
+        alg: The name of the algorithm to test.
+        config: The config to use for the algorithm.
+        train: Whether to train the algorithm for a few iterations.
+        check_bounds: Whether to check the bounds of the action space.
+        frameworks: The frameworks to test the algorithm with.
+        use_gpu: Whether to check support for training on a gpu.
+
+
+    """
+    # Do these imports here because otherwise we have circular imports.
+    from ray.rllib.examples.envs.classes.random_env import RandomEnv
+    from ray.rllib.models.torch.complex_input_net import (
+        ComplexInputNetwork as TorchComplexNet,
+    )
+    from ray.rllib.models.torch.fcnet import FullyConnectedNetwork as TorchFCNet
+    from ray.rllib.models.torch.visionnet import VisionNetwork as TorchVisionNet
+
+    action_spaces_to_test = {
+        # Test discrete twice here until we support multi_binary action spaces
+        "discrete": Discrete(5),
+        "continuous": Box(-1.0, 1.0, (5,), dtype=np.float32),
+        "int_actions": Box(0, 3, (2, 3), dtype=np.int32),
+        "multidiscrete": MultiDiscrete([1, 2, 3, 4]),
+        "tuple": GymTuple(
+            [Discrete(2), Discrete(3), Box(-1.0, 1.0, (5,), dtype=np.float32)]
+        ),
+        "dict": GymDict(
+            {
+                "action_choice": Discrete(3),
+                "parameters": Box(-1.0, 1.0, (1,), dtype=np.float32),
+                "yet_another_nested_dict": GymDict(
+                    {"a": GymTuple([Discrete(2), Discrete(3)])}
+                ),
+            }
+        ),
+    }
+
+    observation_spaces_to_test = {
+        "multi_binary": MultiBinary([3, 10, 10]),
+        "discrete": Discrete(5),
+        "continuous": Box(-1.0, 1.0, (5,), dtype=np.float32),
+        "vector2d": Box(-1.0, 1.0, (5, 5), dtype=np.float32),
+        "image": Box(-1.0, 1.0, (84, 84, 1), dtype=np.float32),
+        "tuple": GymTuple([Discrete(10), Box(-1.0, 1.0, (5,), dtype=np.float32)]),
+        "dict": GymDict(
+            {
+                "task": Discrete(10),
+                "position": Box(-1.0, 1.0, (5,), dtype=np.float32),
+            }
+        ),
+    }
+
+    # The observation spaces that we test RLModules with
+    rlmodule_supported_observation_spaces = [
+        "multi_binary",
+        "discrete",
+        "continuous",
+        "image",
+        "tuple",
+        "dict",
+    ]
+
+    # The action spaces that we test RLModules with
+    rlmodule_supported_action_spaces = ["discrete", "continuous"]
+
+    default_observation_space = default_action_space = "discrete"
+
+    config["log_level"] = "ERROR"
+    config["env"] = RandomEnv
+
+    def _do_check(alg, config, a_name, o_name):
+        # We need to copy here so that this validation does not affect the actual
+        # validation method call further down the line.
+        config_copy = config.copy()
+        config_copy.validate()
+        # If RLModules are enabled, we need to skip a few tests for now:
+        if config_copy.enable_rl_module_and_learner:
+            # Skip PPO cases in which RLModules don't support the given spaces yet.
+            if o_name not in rlmodule_supported_observation_spaces:
+                logger.warning(
+                    "Skipping PPO test with RLModules for obs space {}".format(o_name)
+                )
+                return
+            if a_name not in rlmodule_supported_action_spaces:
+                logger.warning(
+                    "Skipping PPO test with RLModules for action space {}".format(
+                        a_name
+                    )
+                )
+                return
+
+        fw = config["framework"]
+        action_space = action_spaces_to_test[a_name]
+        obs_space = observation_spaces_to_test[o_name]
+        print(
+            "=== Testing {} (fw={}) action_space={} obs_space={} ===".format(
+                alg, fw, action_space, obs_space
+            )
+        )
+        t0 = time.time()
+        config.update_from_dict(
+            dict(
+                env_config=dict(
+                    action_space=action_space,
+                    observation_space=obs_space,
+                    reward_space=Box(1.0, 1.0, shape=(), dtype=np.float32),
+                    p_terminated=1.0,
+                    check_action_bounds=check_bounds,
+                )
+            )
+        )
+        stat = "ok"
+
+        try:
+            algo = config.build()
+        except ray.exceptions.RayActorError as e:
+            if len(e.args) >= 2 and isinstance(e.args[2], UnsupportedSpaceException):
+                stat = "unsupported"
+            elif isinstance(e.args[0].args[2], UnsupportedSpaceException):
+                stat = "unsupported"
+            else:
+                raise
+        except UnsupportedSpaceException:
+            stat = "unsupported"
+        else:
+            if alg not in ["SAC", "PPO"]:
+                # 2D (image) input: Expect VisionNet.
+                if o_name in ["atari", "image"]:
+                    assert isinstance(algo.get_policy().model, TorchVisionNet)
+                # 1D input: Expect FCNet.
+                elif o_name == "continuous":
+                    assert isinstance(algo.get_policy().model, TorchFCNet)
+                # Could be either one: ComplexNet (if disabled Preprocessor)
+                # or FCNet (w/ Preprocessor).
+                elif o_name == "vector2d":
+                    assert isinstance(
+                        algo.get_policy().model, (TorchComplexNet, TorchFCNet)
+                    )
+            if train:
+                algo.train()
+            algo.stop()
+        print("Test: {}, ran in {}s".format(stat, time.time() - t0))
+
+    if not frameworks:
+        frameworks = ("tf2", "tf", "torch")
+
+    _do_check_remote = ray.remote(_do_check)
+    _do_check_remote = _do_check_remote.options(num_gpus=1 if use_gpu else 0)
+    # Test all action spaces first.
+    for a_name in action_spaces_to_test.keys():
+        o_name = default_observation_space
+        ray.get(_do_check_remote.remote(alg, config, a_name, o_name))
+
+    # Now test all observation spaces.
+    for o_name in observation_spaces_to_test.keys():
+        a_name = default_action_space
+        ray.get(_do_check_remote.remote(alg, config, a_name, o_name))

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/tf_utils.py

@@ -0,0 +1,812 @@
+import logging
+from typing import Any, Callable, List, Optional, Type, TYPE_CHECKING, Union
+
+import gymnasium as gym
+import numpy as np
+import tree  # pip install dm_tree
+from gymnasium.spaces import Discrete, MultiDiscrete
+
+from ray.rllib.utils.annotations import PublicAPI, DeveloperAPI
+from ray.rllib.utils.framework import try_import_tf
+from ray.rllib.utils.numpy import SMALL_NUMBER
+from ray.rllib.utils.spaces.space_utils import get_base_struct_from_space
+from ray.rllib.utils.typing import (
+    LocalOptimizer,
+    ModelGradients,
+    NetworkType,
+    PartialAlgorithmConfigDict,
+    SpaceStruct,
+    TensorStructType,
+    TensorType,
+)
+
+if TYPE_CHECKING:
+    from ray.rllib.algorithms.algorithm_config import AlgorithmConfig
+    from ray.rllib.core.learner.learner import ParamDict
+    from ray.rllib.policy.eager_tf_policy import EagerTFPolicy
+    from ray.rllib.policy.eager_tf_policy_v2 import EagerTFPolicyV2
+    from ray.rllib.policy.tf_policy import TFPolicy
+
+logger = logging.getLogger(__name__)
+tf1, tf, tfv = try_import_tf()
+
+
+@PublicAPI
+def clip_gradients(
+    gradients_dict: "ParamDict",
+    *,
+    grad_clip: Optional[float] = None,
+    grad_clip_by: str,
+) -> Optional[float]:
+    """Performs gradient clipping on a grad-dict based on a clip value and clip mode.
+
+    Changes the provided gradient dict in place.
+
+    Args:
+        gradients_dict: The gradients dict, mapping str to gradient tensors.
+        grad_clip: The value to clip with. The way gradients are clipped is defined
+            by the `grad_clip_by` arg (see below).
+        grad_clip_by: One of 'value', 'norm', or 'global_norm'.
+
+    Returns:
+        If `grad_clip_by`="global_norm" and `grad_clip` is not None, returns the global
+        norm of all tensors, otherwise returns None.
+    """
+    # No clipping, return.
+    if grad_clip is None:
+        return
+
+    # Clip by value (each gradient individually).
+    if grad_clip_by == "value":
+        for k, v in gradients_dict.copy().items():
+            gradients_dict[k] = tf.clip_by_value(v, -grad_clip, grad_clip)
+
+    # Clip by L2-norm (per gradient tensor).
+    elif grad_clip_by == "norm":
+        for k, v in gradients_dict.copy().items():
+            gradients_dict[k] = tf.clip_by_norm(v, grad_clip)
+
+    # Clip by global L2-norm (across all gradient tensors).
+    else:
+        assert grad_clip_by == "global_norm"
+
+        clipped_grads, global_norm = tf.clip_by_global_norm(
+            list(gradients_dict.values()), grad_clip
+        )
+        for k, v in zip(gradients_dict.copy().keys(), clipped_grads):
+            gradients_dict[k] = v
+
+        # Return the computed global norm scalar.
+        return global_norm
+
+
+@PublicAPI
+def explained_variance(y: TensorType, pred: TensorType) -> TensorType:
+    """Computes the explained variance for a pair of labels and predictions.
+
+    The formula used is:
+    max(-1.0, 1.0 - (std(y - pred)^2 / std(y)^2))
+
+    Args:
+        y: The labels.
+        pred: The predictions.
+
+    Returns:
+        The explained variance given a pair of labels and predictions.
+    """
+    _, y_var = tf.nn.moments(y, axes=[0])
+    _, diff_var = tf.nn.moments(y - pred, axes=[0])
+    return tf.maximum(-1.0, 1 - (diff_var / (y_var + SMALL_NUMBER)))
+
+
+@PublicAPI
+def flatten_inputs_to_1d_tensor(
+    inputs: TensorStructType,
+    spaces_struct: Optional[SpaceStruct] = None,
+    time_axis: bool = False,
+) -> TensorType:
+    """Flattens arbitrary input structs according to the given spaces struct.
+
+    Returns a single 1D tensor resulting from the different input
+    components' values.
+
+    Thereby:
+    - Boxes (any shape) get flattened to (B, [T]?, -1). Note that image boxes
+    are not treated differently from other types of Boxes and get
+    flattened as well.
+    - Discrete (int) values are one-hot'd, e.g. a batch of [1, 0, 3] (B=3 with
+    Discrete(4) space) results in [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1]].
+    - MultiDiscrete values are multi-one-hot'd, e.g. a batch of
+    [[0, 2], [1, 4]] (B=2 with MultiDiscrete([2, 5]) space) results in
+    [[1, 0,  0, 0, 1, 0, 0], [0, 1,  0, 0, 0, 0, 1]].
+
+    Args:
+        inputs: The inputs to be flattened.
+        spaces_struct: The structure of the spaces that behind the input
+        time_axis: Whether all inputs have a time-axis (after the batch axis).
+            If True, will keep not only the batch axis (0th), but the time axis
+            (1st) as-is and flatten everything from the 2nd axis up.
+
+    Returns:
+        A single 1D tensor resulting from concatenating all
+        flattened/one-hot'd input components. Depending on the time_axis flag,
+        the shape is (B, n) or (B, T, n).
+
+    .. testcode::
+        :skipif: True
+
+        # B=2
+        from ray.rllib.utils.tf_utils import flatten_inputs_to_1d_tensor
+        from gymnasium.spaces import Discrete, Box
+        out = flatten_inputs_to_1d_tensor(
+            {"a": [1, 0], "b": [[[0.0], [0.1]], [1.0], [1.1]]},
+            spaces_struct=dict(a=Discrete(2), b=Box(shape=(2, 1)))
+        )
+        print(out)
+
+        # B=2; T=2
+        out = flatten_inputs_to_1d_tensor(
+            ([[1, 0], [0, 1]],
+             [[[0.0, 0.1], [1.0, 1.1]], [[2.0, 2.1], [3.0, 3.1]]]),
+            spaces_struct=tuple([Discrete(2), Box(shape=(2, ))]),
+            time_axis=True
+        )
+        print(out)
+
+    .. testoutput::
+
+        [[0.0, 1.0,  0.0, 0.1], [1.0, 0.0,  1.0, 1.1]]  # B=2 n=4
+        [[[0.0, 1.0, 0.0, 0.1], [1.0, 0.0, 1.0, 1.1]],
+        [[1.0, 0.0, 2.0, 2.1], [0.0, 1.0, 3.0, 3.1]]]  # B=2 T=2 n=4
+    """
+
+    flat_inputs = tree.flatten(inputs)
+    flat_spaces = (
+        tree.flatten(spaces_struct)
+        if spaces_struct is not None
+        else [None] * len(flat_inputs)
+    )
+
+    B = None
+    T = None
+    out = []
+    for input_, space in zip(flat_inputs, flat_spaces):
+        input_ = tf.convert_to_tensor(input_)
+        shape = tf.shape(input_)
+        # Store batch and (if applicable) time dimension.
+        if B is None:
+            B = shape[0]
+            if time_axis:
+                T = shape[1]
+
+        # One-hot encoding.
+        if isinstance(space, Discrete):
+            if time_axis:
+                input_ = tf.reshape(input_, [B * T])
+            out.append(tf.cast(one_hot(input_, space), tf.float32))
+        elif isinstance(space, MultiDiscrete):
+            if time_axis:
+                input_ = tf.reshape(input_, [B * T, -1])
+            out.append(tf.cast(one_hot(input_, space), tf.float32))
+        # Flatten.
+        else:
+            if time_axis:
+                input_ = tf.reshape(input_, [B * T, -1])
+            else:
+                input_ = tf.reshape(input_, [B, -1])
+            out.append(tf.cast(input_, tf.float32))
+
+    merged = tf.concat(out, axis=-1)
+    # Restore the time-dimension, if applicable.
+    if time_axis:
+        merged = tf.reshape(merged, [B, T, -1])
+
+    return merged
+
+
+@PublicAPI
+def get_gpu_devices() -> List[str]:
+    """Returns a list of GPU device names, e.g. ["/gpu:0", "/gpu:1"].
+
+    Supports both tf1.x and tf2.x.
+
+    Returns:
+        List of GPU device names (str).
+    """
+    if tfv == 1:
+        from tensorflow.python.client import device_lib
+
+        devices = device_lib.list_local_devices()
+    else:
+        try:
+            devices = tf.config.list_physical_devices()
+        except Exception:
+            devices = tf.config.experimental.list_physical_devices()
+
+    # Expect "GPU", but also stuff like: "XLA_GPU".
+    return [d.name for d in devices if "GPU" in d.device_type]
+
+
+@PublicAPI
+def get_placeholder(
+    *,
+    space: Optional[gym.Space] = None,
+    value: Optional[Any] = None,
+    name: Optional[str] = None,
+    time_axis: bool = False,
+    flatten: bool = True,
+) -> "tf1.placeholder":
+    """Returns a tf1.placeholder object given optional hints, such as a space.
+
+    Note that the returned placeholder will always have a leading batch
+    dimension (None).
+
+    Args:
+        space: An optional gym.Space to hint the shape and dtype of the
+            placeholder.
+        value: An optional value to hint the shape and dtype of the
+            placeholder.
+        name: An optional name for the placeholder.
+        time_axis: Whether the placeholder should also receive a time
+            dimension (None).
+        flatten: Whether to flatten the given space into a plain Box space
+            and then create the placeholder from the resulting space.
+
+    Returns:
+        The tf1 placeholder.
+    """
+    from ray.rllib.models.catalog import ModelCatalog
+
+    if space is not None:
+        if isinstance(space, (gym.spaces.Dict, gym.spaces.Tuple)):
+            if flatten:
+                return ModelCatalog.get_action_placeholder(space, None)
+            else:
+                return tree.map_structure_with_path(
+                    lambda path, component: get_placeholder(
+                        space=component,
+                        name=name + "." + ".".join([str(p) for p in path]),
+                    ),
+                    get_base_struct_from_space(space),
+                )
+        return tf1.placeholder(
+            shape=(None,) + ((None,) if time_axis else ()) + space.shape,
+            dtype=tf.float32 if space.dtype == np.float64 else space.dtype,
+            name=name,
+        )
+    else:
+        assert value is not None
+        shape = value.shape[1:]
+        return tf1.placeholder(
+            shape=(None,)
+            + ((None,) if time_axis else ())
+            + (shape if isinstance(shape, tuple) else tuple(shape.as_list())),
+            dtype=tf.float32 if value.dtype == np.float64 else value.dtype,
+            name=name,
+        )
+
+
+@PublicAPI
+def get_tf_eager_cls_if_necessary(
+    orig_cls: Type["TFPolicy"],
+    config: Union["AlgorithmConfig", PartialAlgorithmConfigDict],
+) -> Type[Union["TFPolicy", "EagerTFPolicy", "EagerTFPolicyV2"]]:
+    """Returns the corresponding tf-eager class for a given TFPolicy class.
+
+    Args:
+        orig_cls: The original TFPolicy class to get the corresponding tf-eager
+            class for.
+        config: The Algorithm config dict or AlgorithmConfig object.
+
+    Returns:
+        The tf eager policy class corresponding to the given TFPolicy class.
+    """
+    cls = orig_cls
+    framework = config.get("framework", "tf")
+
+    if framework in ["tf2", "tf"] and not tf1:
+        raise ImportError("Could not import tensorflow!")
+
+    if framework == "tf2":
+        if not tf1.executing_eagerly():
+            tf1.enable_eager_execution()
+        assert tf1.executing_eagerly()
+
+        from ray.rllib.policy.tf_policy import TFPolicy
+        from ray.rllib.policy.eager_tf_policy import EagerTFPolicy
+        from ray.rllib.policy.eager_tf_policy_v2 import EagerTFPolicyV2
+
+        # Create eager-class (if not already one).
+        if hasattr(orig_cls, "as_eager") and not issubclass(orig_cls, EagerTFPolicy):
+            cls = orig_cls.as_eager()
+        # Could be some other type of policy or already
+        # eager-ized.
+        elif not issubclass(orig_cls, TFPolicy):
+            pass
+        else:
+            raise ValueError(
+                "This policy does not support eager execution: {}".format(orig_cls)
+            )
+
+        # Now that we know, policy is an eager one, add tracing, if necessary.
+        if config.get("eager_tracing") and issubclass(
+            cls, (EagerTFPolicy, EagerTFPolicyV2)
+        ):
+            cls = cls.with_tracing()
+    return cls
+
+
+@PublicAPI
+def huber_loss(x: TensorType, delta: float = 1.0) -> TensorType:
+    """Computes the huber loss for a given term and delta parameter.
+
+    Reference: https://en.wikipedia.org/wiki/Huber_loss
+    Note that the factor of 0.5 is implicitly included in the calculation.
+
+    Formula:
+        L = 0.5 * x^2  for small abs x (delta threshold)
+        L = delta * (abs(x) - 0.5*delta)  for larger abs x (delta threshold)
+
+    Args:
+        x: The input term, e.g. a TD error.
+        delta: The delta parmameter in the above formula.
+
+    Returns:
+        The Huber loss resulting from `x` and `delta`.
+    """
+    return tf.where(
+        tf.abs(x) < delta,  # for small x -> apply the Huber correction
+        tf.math.square(x) * 0.5,
+        delta * (tf.abs(x) - 0.5 * delta),
+    )
+
+
+@PublicAPI
+def l2_loss(x: TensorType) -> TensorType:
+    """Computes half the L2 norm over a tensor's values without the sqrt.
+
+    output = 0.5 * sum(x ** 2)
+
+    Args:
+        x: The input tensor.
+
+    Returns:
+        0.5 times the L2 norm over the given tensor's values (w/o sqrt).
+    """
+    return 0.5 * tf.reduce_sum(tf.pow(x, 2.0))
+
+
+@PublicAPI
+def make_tf_callable(
+    session_or_none: Optional["tf1.Session"], dynamic_shape: bool = False
+) -> Callable:
+    """Returns a function that can be executed in either graph or eager mode.
+
+    The function must take only positional args.
+
+    If eager is enabled, this will act as just a function. Otherwise, it
+    will build a function that executes a session run with placeholders
+    internally.
+
+    Args:
+        session_or_none: tf.Session if in graph mode, else None.
+        dynamic_shape: True if the placeholders should have a dynamic
+            batch dimension. Otherwise they will be fixed shape.
+
+    Returns:
+        A function that can be called in either eager or static-graph mode.
+    """
+
+    if tf.executing_eagerly():
+        assert session_or_none is None
+    else:
+        assert session_or_none is not None
+
+    def make_wrapper(fn):
+        # Static-graph mode: Create placeholders and make a session call each
+        # time the wrapped function is called. Returns the output of this
+        # session call.
+        if session_or_none is not None:
+            args_placeholders = []
+            kwargs_placeholders = {}
+
+            symbolic_out = [None]
+
+            def call(*args, **kwargs):
+                args_flat = []
+                for a in args:
+                    if type(a) is list:
+                        args_flat.extend(a)
+                    else:
+                        args_flat.append(a)
+                args = args_flat
+
+                # We have not built any placeholders yet: Do this once here,
+                # then reuse the same placeholders each time we call this
+                # function again.
+                if symbolic_out[0] is None:
+                    with session_or_none.graph.as_default():
+
+                        def _create_placeholders(path, value):
+                            if dynamic_shape:
+                                if len(value.shape) > 0:
+                                    shape = (None,) + value.shape[1:]
+                                else:
+                                    shape = ()
+                            else:
+                                shape = value.shape
+                            return tf1.placeholder(
+                                dtype=value.dtype,
+                                shape=shape,
+                                name=".".join([str(p) for p in path]),
+                            )
+
+                        placeholders = tree.map_structure_with_path(
+                            _create_placeholders, args
+                        )
+                        for ph in tree.flatten(placeholders):
+                            args_placeholders.append(ph)
+
+                        placeholders = tree.map_structure_with_path(
+                            _create_placeholders, kwargs
+                        )
+                        for k, ph in placeholders.items():
+                            kwargs_placeholders[k] = ph
+
+                        symbolic_out[0] = fn(*args_placeholders, **kwargs_placeholders)
+                feed_dict = dict(zip(args_placeholders, tree.flatten(args)))
+                tree.map_structure(
+                    lambda ph, v: feed_dict.__setitem__(ph, v),
+                    kwargs_placeholders,
+                    kwargs,
+                )
+                ret = session_or_none.run(symbolic_out[0], feed_dict)
+                return ret
+
+            return call
+        # Eager mode (call function as is).
+        else:
+            return fn
+
+    return make_wrapper
+
+
+# TODO (sven): Deprecate this function once we have moved completely to the Learner API.
+#  Replaced with `clip_gradients()`.
+@PublicAPI
+def minimize_and_clip(
+    optimizer: LocalOptimizer,
+    objective: TensorType,
+    var_list: List["tf.Variable"],
+    clip_val: float = 10.0,
+) -> ModelGradients:
+    """Computes, then clips gradients using objective, optimizer and var list.
+
+    Ensures the norm of the gradients for each variable is clipped to
+    `clip_val`.
+
+    Args:
+        optimizer: Either a shim optimizer (tf eager) containing a
+            tf.GradientTape under `self.tape` or a tf1 local optimizer
+            object.
+        objective: The loss tensor to calculate gradients on.
+        var_list: The list of tf.Variables to compute gradients over.
+        clip_val: The global norm clip value. Will clip around -clip_val and
+            +clip_val.
+
+    Returns:
+        The resulting model gradients (list or tuples of grads + vars)
+        corresponding to the input `var_list`.
+    """
+    # Accidentally passing values < 0.0 will break all gradients.
+    assert clip_val is None or clip_val > 0.0, clip_val
+
+    if tf.executing_eagerly():
+        tape = optimizer.tape
+        grads_and_vars = list(zip(list(tape.gradient(objective, var_list)), var_list))
+    else:
+        grads_and_vars = optimizer.compute_gradients(objective, var_list=var_list)
+
+    return [
+        (tf.clip_by_norm(g, clip_val) if clip_val is not None else g, v)
+        for (g, v) in grads_and_vars
+        if g is not None
+    ]
+
+
+@PublicAPI
+def one_hot(x: TensorType, space: gym.Space) -> TensorType:
+    """Returns a one-hot tensor, given and int tensor and a space.
+
+    Handles the MultiDiscrete case as well.
+
+    Args:
+        x: The input tensor.
+        space: The space to use for generating the one-hot tensor.
+
+    Returns:
+        The resulting one-hot tensor.
+
+    Raises:
+        ValueError: If the given space is not a discrete one.
+
+    .. testcode::
+        :skipif: True
+
+        import gymnasium as gym
+        import tensorflow as tf
+        from ray.rllib.utils.tf_utils import one_hot
+        x = tf.Variable([0, 3], dtype=tf.int32)  # batch-dim=2
+        # Discrete space with 4 (one-hot) slots per batch item.
+        s = gym.spaces.Discrete(4)
+        one_hot(x, s)
+
+    .. testoutput::
+
+        <tf.Tensor 'one_hot:0' shape=(2, 4) dtype=float32>
+
+    .. testcode::
+        :skipif: True
+
+        x = tf.Variable([[0, 1, 2, 3]], dtype=tf.int32)  # batch-dim=1
+        # MultiDiscrete space with 5 + 4 + 4 + 7 = 20 (one-hot) slots
+        # per batch item.
+        s = gym.spaces.MultiDiscrete([5, 4, 4, 7])
+        one_hot(x, s)
+
+    .. testoutput::
+
+        <tf.Tensor 'concat:0' shape=(1, 20) dtype=float32>
+    """
+    if isinstance(space, Discrete):
+        return tf.one_hot(x, space.n, dtype=tf.float32)
+    elif isinstance(space, MultiDiscrete):
+        if isinstance(space.nvec[0], np.ndarray):
+            nvec = np.ravel(space.nvec)
+            x = tf.reshape(x, (x.shape[0], -1))
+        else:
+            nvec = space.nvec
+        return tf.concat(
+            [tf.one_hot(x[:, i], n, dtype=tf.float32) for i, n in enumerate(nvec)],
+            axis=-1,
+        )
+    else:
+        raise ValueError("Unsupported space for `one_hot`: {}".format(space))
+
+
+@PublicAPI
+def reduce_mean_ignore_inf(x: TensorType, axis: Optional[int] = None) -> TensorType:
+    """Same as tf.reduce_mean() but ignores -inf values.
+
+    Args:
+        x: The input tensor to reduce mean over.
+        axis: The axis over which to reduce. None for all axes.
+
+    Returns:
+        The mean reduced inputs, ignoring inf values.
+    """
+    mask = tf.not_equal(x, tf.float32.min)
+    x_zeroed = tf.where(mask, x, tf.zeros_like(x))
+    return tf.math.reduce_sum(x_zeroed, axis) / tf.math.reduce_sum(
+        tf.cast(mask, tf.float32), axis
+    )
+
+
+@PublicAPI
+def scope_vars(
+    scope: Union[str, "tf1.VariableScope"], trainable_only: bool = False
+) -> List["tf.Variable"]:
+    """Get variables inside a given scope.
+
+    Args:
+        scope: Scope in which the variables reside.
+        trainable_only: Whether or not to return only the variables that were
+            marked as trainable.
+
+    Returns:
+        The list of variables in the given `scope`.
+    """
+    return tf1.get_collection(
+        tf1.GraphKeys.TRAINABLE_VARIABLES
+        if trainable_only
+        else tf1.GraphKeys.VARIABLES,
+        scope=scope if isinstance(scope, str) else scope.name,
+    )
+
+
+@PublicAPI
+def symlog(x: "tf.Tensor") -> "tf.Tensor":
+    """The symlog function as described in [1]:
+
+    [1] Mastering Diverse Domains through World Models - 2023
+    D. Hafner, J. Pasukonis, J. Ba, T. Lillicrap
+    https://arxiv.org/pdf/2301.04104v1.pdf
+    """
+    return tf.math.sign(x) * tf.math.log(tf.math.abs(x) + 1)
+
+
+@PublicAPI
+def inverse_symlog(y: "tf.Tensor") -> "tf.Tensor":
+    """Inverse of the `symlog` function as desribed in [1]:
+
+    [1] Mastering Diverse Domains through World Models - 2023
+    D. Hafner, J. Pasukonis, J. Ba, T. Lillicrap
+    https://arxiv.org/pdf/2301.04104v1.pdf
+    """
+    # To get to symlog inverse, we solve the symlog equation for x:
+    #     y = sign(x) * log(|x| + 1)
+    # <=> y / sign(x) = log(|x| + 1)
+    # <=> y =  log( x + 1) V x >= 0
+    #    -y =  log(-x + 1) V x <  0
+    # <=> exp(y)  =  x + 1  V x >= 0
+    #     exp(-y) = -x + 1  V x <  0
+    # <=> exp(y)  - 1 =  x   V x >= 0
+    #     exp(-y) - 1 = -x   V x <  0
+    # <=>  exp(y)  - 1 = x   V x >= 0 (if x >= 0, then y must also be >= 0)
+    #     -exp(-y) - 1 = x   V x <  0 (if x < 0, then y must also be < 0)
+    # <=> sign(y) * (exp(|y|) - 1) = x
+    return tf.math.sign(y) * (tf.math.exp(tf.math.abs(y)) - 1)
+
+
+@PublicAPI
+def two_hot(
+    value: "tf.Tensor",
+    num_buckets: int = 255,
+    lower_bound: float = -20.0,
+    upper_bound: float = 20.0,
+    dtype=None,
+):
+    """Returns a two-hot vector of dim=num_buckets with two entries that are non-zero.
+
+    See [1] for more details:
+    [1] Mastering Diverse Domains through World Models - 2023
+    D. Hafner, J. Pasukonis, J. Ba, T. Lillicrap
+    https://arxiv.org/pdf/2301.04104v1.pdf
+
+    Entries in the vector represent equally sized buckets within some fixed range
+    (`lower_bound` to `upper_bound`).
+    Those entries not 0.0 at positions k and k+1 encode the actual `value` and sum
+    up to 1.0. They are the weights multiplied by the buckets values at k and k+1 for
+    retrieving `value`.
+
+    Example:
+        num_buckets=11
+        lower_bound=-5
+        upper_bound=5
+        value=2.5
+        -> [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0]
+        -> [-5   -4   -3   -2   -1   0    1    2    3    4    5] (0.5*2 + 0.5*3=2.5)
+
+    Example:
+        num_buckets=5
+        lower_bound=-1
+        upper_bound=1
+        value=0.1
+        -> [0.0, 0.0, 0.8, 0.2, 0.0]
+        -> [-1  -0.5   0   0.5   1] (0.2*0.5 + 0.8*0=0.1)
+
+    Args:
+        value: The input tensor of shape (B,) to be two-hot encoded.
+        num_buckets: The number of buckets to two-hot encode into.
+        lower_bound: The lower bound value used for the encoding. If input values are
+            lower than this boundary, they will be encoded as `lower_bound`.
+        upper_bound: The upper bound value used for the encoding. If input values are
+            higher than this boundary, they will be encoded as `upper_bound`.
+
+    Returns:
+        The two-hot encoded tensor of shape (B, num_buckets).
+    """
+    # First make sure, values are clipped.
+    value = tf.clip_by_value(value, lower_bound, upper_bound)
+    # Tensor of batch indices: [0, B=batch size).
+    batch_indices = tf.cast(
+        tf.range(0, tf.shape(value)[0]),
+        dtype=dtype or tf.float32,
+    )
+    # Calculate the step deltas (how much space between each bucket's central value?).
+    bucket_delta = (upper_bound - lower_bound) / (num_buckets - 1)
+    # Compute the float indices (might be non-int numbers: sitting between two buckets).
+    idx = (-lower_bound + value) / bucket_delta
+    # k
+    k = tf.math.floor(idx)
+    # k+1
+    kp1 = tf.math.ceil(idx)
+    # In case k == kp1 (idx is exactly on the bucket boundary), move kp1 up by 1.0.
+    # Otherwise, this would result in a NaN in the returned two-hot tensor.
+    kp1 = tf.where(tf.equal(k, kp1), kp1 + 1.0, kp1)
+    # Iff `kp1` is one beyond our last index (because incoming value is larger than
+    # `upper_bound`), move it to one before k (kp1's weight is going to be 0.0 anyways,
+    # so it doesn't matter where it points to; we are just avoiding an index error
+    # with this).
+    kp1 = tf.where(tf.equal(kp1, num_buckets), kp1 - 2.0, kp1)
+    # The actual values found at k and k+1 inside the set of buckets.
+    values_k = lower_bound + k * bucket_delta
+    values_kp1 = lower_bound + kp1 * bucket_delta
+    # Compute the two-hot weights (adding up to 1.0) to use at index k and k+1.
+    weights_k = (value - values_kp1) / (values_k - values_kp1)
+    weights_kp1 = 1.0 - weights_k
+    # Compile a tensor of full paths (indices from batch index to feature index) to
+    # use for the scatter_nd op.
+    indices_k = tf.stack([batch_indices, k], -1)
+    indices_kp1 = tf.stack([batch_indices, kp1], -1)
+    indices = tf.concat([indices_k, indices_kp1], 0)
+    # The actual values (weights adding up to 1.0) to place at the computed indices.
+    updates = tf.concat([weights_k, weights_kp1], 0)
+    # Call the actual scatter update op, returning a zero-filled tensor, only changed
+    # at the given indices.
+    return tf.scatter_nd(
+        tf.cast(indices, tf.int32),
+        updates,
+        shape=(tf.shape(value)[0], num_buckets),
+    )
+
+
+@PublicAPI
+def update_target_network(
+    main_net: NetworkType,
+    target_net: NetworkType,
+    tau: float,
+) -> None:
+    """Updates a keras.Model target network using Polyak averaging.
+
+    new_target_net_weight = (
+        tau * main_net_weight + (1.0 - tau) * current_target_net_weight
+    )
+
+    Args:
+        main_net: The keras.Model to update from.
+        target_net: The target network to update.
+        tau: The tau value to use in the Polyak averaging formula.
+    """
+    for old_var, current_var in zip(target_net.variables, main_net.variables):
+        updated_var = tau * current_var + (1.0 - tau) * old_var
+        old_var.assign(updated_var)
+
+
+@PublicAPI
+def zero_logps_from_actions(actions: TensorStructType) -> TensorType:
+    """Helper function useful for returning dummy logp's (0) for some actions.
+
+    Args:
+        actions: The input actions. This can be any struct
+            of complex action components or a simple tensor of different
+            dimensions, e.g. [B], [B, 2], or {"a": [B, 4, 5], "b": [B]}.
+
+    Returns:
+        A 1D tensor of 0.0 (dummy logp's) matching the batch
+        dim of `actions` (shape=[B]).
+    """
+    # Need to flatten `actions` in case we have a complex action space.
+    # Take the 0th component to extract the batch dim.
+    action_component = tree.flatten(actions)[0]
+    logp_ = tf.zeros_like(action_component, dtype=tf.float32)
+    # Logp's should be single values (but with the same batch dim as
+    # `deterministic_actions` or `stochastic_actions`). In case
+    # actions are just [B], zeros_like works just fine here, but if
+    # actions are [B, ...], we have to reduce logp back to just [B].
+    while len(logp_.shape) > 1:
+        logp_ = logp_[:, 0]
+    return logp_
+
+
+@DeveloperAPI
+def warn_if_infinite_kl_divergence(
+    policy: Type["TFPolicy"], mean_kl: TensorType
+) -> None:
+    def print_warning():
+        logger.warning(
+            "KL divergence is non-finite, this will likely destabilize your model and"
+            " the training process. Action(s) in a specific state have near-zero"
+            " probability. This can happen naturally in deterministic environments"
+            " where the optimal policy has zero mass for a specific action. To fix this"
+            " issue, consider setting the coefficient for the KL loss term to zero or"
+            " increasing policy entropy."
+        )
+        return tf.constant(0.0)
+
+    if policy.loss_initialized():
+        tf.cond(
+            tf.math.is_inf(mean_kl),
+            false_fn=lambda: tf.constant(0.0),
+            true_fn=lambda: print_warning(),
+        )

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/threading.py

@@ -0,0 +1,34 @@
+from typing import Callable
+
+from ray.rllib.utils.annotations import OldAPIStack
+
+
+@OldAPIStack
+def with_lock(func: Callable) -> Callable:
+    """Use as decorator (@withlock) around object methods that need locking.
+
+    Note: The object must have a self._lock = threading.Lock() property.
+    Locking thus works on the object level (no two locked methods of the same
+    object can be called asynchronously).
+
+    Args:
+        func: The function to decorate/wrap.
+
+    Returns:
+        The wrapped (object-level locked) function.
+    """
+
+    def wrapper(self, *a, **k):
+        try:
+            with self._lock:
+                return func(self, *a, **k)
+        except AttributeError as e:
+            if "has no attribute '_lock'" in e.args[0]:
+                raise AttributeError(
+                    "Object {} must have a `self._lock` property (assigned "
+                    "to a threading.RLock() object in its "
+                    "constructor)!".format(self)
+                )
+            raise e
+
+    return wrapper

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/torch_utils.py

@@ -0,0 +1,745 @@
+import logging
+import os
+import warnings
+from typing import Dict, List, Optional, TYPE_CHECKING, Union
+
+import gymnasium as gym
+from gymnasium.spaces import Discrete, MultiDiscrete
+import numpy as np
+from packaging import version
+import tree  # pip install dm_tree
+
+from ray.rllib.models.repeated_values import RepeatedValues
+from ray.rllib.utils.annotations import PublicAPI, DeveloperAPI
+from ray.rllib.utils.framework import try_import_torch
+from ray.rllib.utils.numpy import SMALL_NUMBER
+from ray.rllib.utils.typing import (
+    LocalOptimizer,
+    NetworkType,
+    SpaceStruct,
+    TensorStructType,
+    TensorType,
+)
+
+if TYPE_CHECKING:
+    from ray.rllib.core.learner.learner import ParamDict, ParamList
+    from ray.rllib.policy.torch_policy import TorchPolicy
+    from ray.rllib.policy.torch_policy_v2 import TorchPolicyV2
+
+logger = logging.getLogger(__name__)
+torch, nn = try_import_torch()
+
+# Limit values suitable for use as close to a -inf logit. These are useful
+# since -inf / inf cause NaNs during backprop.
+FLOAT_MIN = -3.4e38
+FLOAT_MAX = 3.4e38
+
+if torch:
+    TORCH_COMPILE_REQUIRED_VERSION = version.parse("2.0.0")
+else:
+    TORCH_COMPILE_REQUIRED_VERSION = ValueError(
+        "torch is not installed. " "TORCH_COMPILE_REQUIRED_VERSION is " "not defined."
+    )
+
+
+# TODO (sven): Deprecate this function once we have moved completely to the Learner API.
+#  Replaced with `clip_gradients()`.
+@PublicAPI
+def apply_grad_clipping(
+    policy: "TorchPolicy", optimizer: LocalOptimizer, loss: TensorType
+) -> Dict[str, TensorType]:
+    """Applies gradient clipping to already computed grads inside `optimizer`.
+
+    Note: This function does NOT perform an analogous operation as
+    tf.clip_by_global_norm. It merely clips by norm (per gradient tensor) and
+    then computes the global norm across all given tensors (but without clipping
+    by that global norm).
+
+    Args:
+        policy: The TorchPolicy, which calculated `loss`.
+        optimizer: A local torch optimizer object.
+        loss: The torch loss tensor.
+
+    Returns:
+        An info dict containing the "grad_norm" key and the resulting clipped
+        gradients.
+    """
+    grad_gnorm = 0
+    if policy.config["grad_clip"] is not None:
+        clip_value = policy.config["grad_clip"]
+    else:
+        clip_value = np.inf
+
+    num_none_grads = 0
+    for param_group in optimizer.param_groups:
+        # Make sure we only pass params with grad != None into torch
+        # clip_grad_norm_. Would fail otherwise.
+        params = list(filter(lambda p: p.grad is not None, param_group["params"]))
+        if params:
+            # PyTorch clips gradients inplace and returns the norm before clipping
+            # We therefore need to compute grad_gnorm further down (fixes #4965)
+            global_norm = nn.utils.clip_grad_norm_(params, clip_value)
+
+            if isinstance(global_norm, torch.Tensor):
+                global_norm = global_norm.cpu().numpy()
+
+            grad_gnorm += min(global_norm, clip_value)
+        else:
+            num_none_grads += 1
+
+    # Note (Kourosh): grads could indeed be zero. This method should still return
+    # grad_gnorm in that case.
+    if num_none_grads == len(optimizer.param_groups):
+        # No grads available
+        return {}
+    return {"grad_gnorm": grad_gnorm}
+
+
+@PublicAPI
+def clip_gradients(
+    gradients_dict: "ParamDict",
+    *,
+    grad_clip: Optional[float] = None,
+    grad_clip_by: str = "value",
+) -> TensorType:
+    """Performs gradient clipping on a grad-dict based on a clip value and clip mode.
+
+    Changes the provided gradient dict in place.
+
+    Args:
+        gradients_dict: The gradients dict, mapping str to gradient tensors.
+        grad_clip: The value to clip with. The way gradients are clipped is defined
+            by the `grad_clip_by` arg (see below).
+        grad_clip_by: One of 'value', 'norm', or 'global_norm'.
+
+    Returns:
+        If `grad_clip_by`="global_norm" and `grad_clip` is not None, returns the global
+        norm of all tensors, otherwise returns None.
+    """
+    # No clipping, return.
+    if grad_clip is None:
+        return
+
+    # Clip by value (each gradient individually).
+    if grad_clip_by == "value":
+        for k, v in gradients_dict.copy().items():
+            gradients_dict[k] = (
+                None if v is None else torch.clip(v, -grad_clip, grad_clip)
+            )
+
+    # Clip by L2-norm (per gradient tensor).
+    elif grad_clip_by == "norm":
+        for k, v in gradients_dict.copy().items():
+            if v is not None:
+                # Compute the L2-norm of the gradient tensor.
+                norm = v.norm(2).nan_to_num(neginf=-10e8, posinf=10e8)
+                # Clip all the gradients.
+                if norm > grad_clip:
+                    v.mul_(grad_clip / norm)
+
+    # Clip by global L2-norm (across all gradient tensors).
+    else:
+        assert (
+            grad_clip_by == "global_norm"
+        ), f"`grad_clip_by` ({grad_clip_by}) must be one of [value|norm|global_norm]!"
+        gradients_list = list(gradients_dict.values())
+        total_norm = compute_global_norm(gradients_list)
+        # We do want the coefficient to be in between 0.0 and 1.0, therefore
+        # if the global_norm is smaller than the clip value, we use the clip value
+        # as normalization constant.
+        device = gradients_list[0].device
+        clip_coef = grad_clip / torch.maximum(
+            torch.tensor(grad_clip).to(device), total_norm + 1e-6
+        )
+        # Note: multiplying by the clamped coef is redundant when the coef is clamped to
+        # 1, but doing so avoids a `if clip_coef < 1:` conditional which can require a
+        # CPU <=> device synchronization when the gradients do not reside in CPU memory.
+        clip_coef_clamped = torch.clamp(clip_coef, max=1.0)
+        for g in gradients_list:
+            if g is not None:
+                g.detach().mul_(clip_coef_clamped.to(g.device))
+        return total_norm
+
+
+@PublicAPI
+def compute_global_norm(gradients_list: "ParamList") -> TensorType:
+    """Computes the global norm for a gradients dict.
+
+    Args:
+        gradients_list: The gradients list containing parameters.
+
+    Returns:
+        Returns the global norm of all tensors in `gradients_list`.
+    """
+    # Define the norm type to be L2.
+    norm_type = 2.0
+    # If we have no grads, return zero.
+    if len(gradients_list) == 0:
+        return torch.tensor(0.0)
+    device = gradients_list[0].device
+
+    # Compute the global norm.
+    total_norm = torch.norm(
+        torch.stack(
+            [
+                torch.norm(g.detach(), norm_type)
+                # Note, we want to avoid overflow in the norm computation, this does
+                # not affect the gradients themselves as we clamp by multiplying and
+                # not by overriding tensor values.
+                .nan_to_num(neginf=-10e8, posinf=10e8).to(device)
+                for g in gradients_list
+                if g is not None
+            ]
+        ),
+        norm_type,
+    ).nan_to_num(neginf=-10e8, posinf=10e8)
+    if torch.logical_or(total_norm.isnan(), total_norm.isinf()):
+        raise RuntimeError(
+            f"The total norm of order {norm_type} for gradients from "
+            "`parameters` is non-finite, so it cannot be clipped. "
+        )
+    # Return the global norm.
+    return total_norm
+
+
+@PublicAPI
+def concat_multi_gpu_td_errors(
+    policy: Union["TorchPolicy", "TorchPolicyV2"]
+) -> Dict[str, TensorType]:
+    """Concatenates multi-GPU (per-tower) TD error tensors given TorchPolicy.
+
+    TD-errors are extracted from the TorchPolicy via its tower_stats property.
+
+    Args:
+        policy: The TorchPolicy to extract the TD-error values from.
+
+    Returns:
+        A dict mapping strings "td_error" and "mean_td_error" to the
+        corresponding concatenated and mean-reduced values.
+    """
+    td_error = torch.cat(
+        [
+            t.tower_stats.get("td_error", torch.tensor([0.0])).to(policy.device)
+            for t in policy.model_gpu_towers
+        ],
+        dim=0,
+    )
+    policy.td_error = td_error
+    return {
+        "td_error": td_error,
+        "mean_td_error": torch.mean(td_error),
+    }
+
+
+@PublicAPI
+def convert_to_torch_tensor(
+    x: TensorStructType,
+    device: Optional[str] = None,
+    pin_memory: bool = False,
+):
+    """Converts any struct to torch.Tensors.
+
+    Args:
+        x: Any (possibly nested) struct, the values in which will be
+            converted and returned as a new struct with all leaves converted
+            to torch tensors.
+        device: The device to create the tensor on.
+        pin_memory: If True, will call the `pin_memory()` method on the created tensors.
+
+    Returns:
+        Any: A new struct with the same structure as `x`, but with all
+        values converted to torch Tensor types. This does not convert possibly
+        nested elements that are None because torch has no representation for that.
+    """
+
+    def mapping(item):
+        if item is None:
+            # Torch has no representation for `None`, so we return None
+            return item
+
+        # Special handling of "Repeated" values.
+        if isinstance(item, RepeatedValues):
+            return RepeatedValues(
+                tree.map_structure(mapping, item.values), item.lengths, item.max_len
+            )
+
+        # Already torch tensor -> make sure it's on right device.
+        if torch.is_tensor(item):
+            tensor = item
+        # Numpy arrays.
+        elif isinstance(item, np.ndarray):
+            # Object type (e.g. info dicts in train batch): leave as-is.
+            # str type (e.g. agent_id in train batch): leave as-is.
+            if item.dtype == object or item.dtype.type is np.str_:
+                return item
+            # Non-writable numpy-arrays will cause PyTorch warning.
+            elif item.flags.writeable is False:
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore")
+                    tensor = torch.from_numpy(item)
+            # Already numpy: Wrap as torch tensor.
+            else:
+                tensor = torch.from_numpy(item)
+        # Everything else: Convert to numpy, then wrap as torch tensor.
+        else:
+            tensor = torch.from_numpy(np.asarray(item))
+
+        # Floatify all float64 tensors (but leave float16 as-is).
+        if tensor.is_floating_point() and str(tensor.dtype) != "torch.float16":
+            tensor = tensor.float()
+
+        # Pin the tensor's memory (for faster transfer to GPU later).
+        if pin_memory and torch.cuda.is_available():
+            tensor.pin_memory()
+
+        return tensor if device is None else tensor.to(device)
+
+    return tree.map_structure(mapping, x)
+
+
+@PublicAPI
+def copy_torch_tensors(x: TensorStructType, device: Optional[str] = None):
+    """Creates a copy of `x` and makes deep copies torch.Tensors in x.
+
+    Also moves the copied tensors to the specified device (if not None).
+
+    Note if an object in x is not a torch.Tensor, it will be shallow-copied.
+
+    Args:
+        x : Any (possibly nested) struct possibly containing torch.Tensors.
+        device : The device to move the tensors to.
+
+    Returns:
+        Any: A new struct with the same structure as `x`, but with all
+            torch.Tensors deep-copied and moved to the specified device.
+
+    """
+
+    def mapping(item):
+        if isinstance(item, torch.Tensor):
+            return (
+                torch.clone(item.detach())
+                if device is None
+                else item.detach().to(device)
+            )
+        else:
+            return item
+
+    return tree.map_structure(mapping, x)
+
+
+@PublicAPI
+def explained_variance(y: TensorType, pred: TensorType) -> TensorType:
+    """Computes the explained variance for a pair of labels and predictions.
+
+    The formula used is:
+    max(-1.0, 1.0 - (std(y - pred)^2 / std(y)^2))
+
+    Args:
+        y: The labels.
+        pred: The predictions.
+
+    Returns:
+        The explained variance given a pair of labels and predictions.
+    """
+    y_var = torch.var(y, dim=[0])
+    diff_var = torch.var(y - pred, dim=[0])
+    min_ = torch.tensor([-1.0]).to(pred.device)
+    return torch.max(min_, 1 - (diff_var / (y_var + SMALL_NUMBER)))[0]
+
+
+@PublicAPI
+def flatten_inputs_to_1d_tensor(
+    inputs: TensorStructType,
+    spaces_struct: Optional[SpaceStruct] = None,
+    time_axis: bool = False,
+) -> TensorType:
+    """Flattens arbitrary input structs according to the given spaces struct.
+
+    Returns a single 1D tensor resulting from the different input
+    components' values.
+
+    Thereby:
+    - Boxes (any shape) get flattened to (B, [T]?, -1). Note that image boxes
+    are not treated differently from other types of Boxes and get
+    flattened as well.
+    - Discrete (int) values are one-hot'd, e.g. a batch of [1, 0, 3] (B=3 with
+    Discrete(4) space) results in [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1]].
+    - MultiDiscrete values are multi-one-hot'd, e.g. a batch of
+    [[0, 2], [1, 4]] (B=2 with MultiDiscrete([2, 5]) space) results in
+    [[1, 0,  0, 0, 1, 0, 0], [0, 1,  0, 0, 0, 0, 1]].
+
+    Args:
+        inputs: The inputs to be flattened.
+        spaces_struct: The structure of the spaces that behind the input
+        time_axis: Whether all inputs have a time-axis (after the batch axis).
+            If True, will keep not only the batch axis (0th), but the time axis
+            (1st) as-is and flatten everything from the 2nd axis up.
+
+    Returns:
+        A single 1D tensor resulting from concatenating all
+        flattened/one-hot'd input components. Depending on the time_axis flag,
+        the shape is (B, n) or (B, T, n).
+
+    .. testcode::
+
+        from gymnasium.spaces import Discrete, Box
+        from ray.rllib.utils.torch_utils import flatten_inputs_to_1d_tensor
+        import torch
+        struct = {
+            "a": np.array([1, 3]),
+            "b": (
+                np.array([[1.0, 2.0], [4.0, 5.0]]),
+                np.array(
+                    [[[8.0], [7.0]], [[5.0], [4.0]]]
+                ),
+            ),
+                "c": {
+                    "cb": np.array([1.0, 2.0]),
+                },
+        }
+        struct_torch = tree.map_structure(lambda s: torch.from_numpy(s), struct)
+        spaces = dict(
+            {
+                "a": gym.spaces.Discrete(4),
+                "b": (gym.spaces.Box(-1.0, 10.0, (2,)), gym.spaces.Box(-1.0, 1.0, (2,
+                        1))),
+                "c": dict(
+                    {
+                        "cb": gym.spaces.Box(-1.0, 1.0, ()),
+                    }
+                ),
+            }
+        )
+        print(flatten_inputs_to_1d_tensor(struct_torch, spaces_struct=spaces))
+
+    .. testoutput::
+
+        tensor([[0., 1., 0., 0., 1., 2., 8., 7., 1.],
+                [0., 0., 0., 1., 4., 5., 5., 4., 2.]])
+
+    """
+
+    flat_inputs = tree.flatten(inputs)
+    flat_spaces = (
+        tree.flatten(spaces_struct)
+        if spaces_struct is not None
+        else [None] * len(flat_inputs)
+    )
+
+    B = None
+    T = None
+    out = []
+    for input_, space in zip(flat_inputs, flat_spaces):
+        # Store batch and (if applicable) time dimension.
+        if B is None:
+            B = input_.shape[0]
+            if time_axis:
+                T = input_.shape[1]
+
+        # One-hot encoding.
+        if isinstance(space, Discrete):
+            if time_axis:
+                input_ = torch.reshape(input_, [B * T])
+            out.append(one_hot(input_, space).float())
+        # Multi one-hot encoding.
+        elif isinstance(space, MultiDiscrete):
+            if time_axis:
+                input_ = torch.reshape(input_, [B * T, -1])
+            out.append(one_hot(input_, space).float())
+        # Box: Flatten.
+        else:
+            if time_axis:
+                input_ = torch.reshape(input_, [B * T, -1])
+            else:
+                input_ = torch.reshape(input_, [B, -1])
+            out.append(input_.float())
+
+    merged = torch.cat(out, dim=-1)
+    # Restore the time-dimension, if applicable.
+    if time_axis:
+        merged = torch.reshape(merged, [B, T, -1])
+
+    return merged
+
+
+@PublicAPI
+def global_norm(tensors: List[TensorType]) -> TensorType:
+    """Returns the global L2 norm over a list of tensors.
+
+    output = sqrt(SUM(t ** 2 for t in tensors)),
+        where SUM reduces over all tensors and over all elements in tensors.
+
+    Args:
+        tensors: The list of tensors to calculate the global norm over.
+
+    Returns:
+        The global L2 norm over the given tensor list.
+    """
+    # List of single tensors' L2 norms: SQRT(SUM(xi^2)) over all xi in tensor.
+    single_l2s = [torch.pow(torch.sum(torch.pow(t, 2.0)), 0.5) for t in tensors]
+    # Compute global norm from all single tensors' L2 norms.
+    return torch.pow(sum(torch.pow(l2, 2.0) for l2 in single_l2s), 0.5)
+
+
+@PublicAPI
+def huber_loss(x: TensorType, delta: float = 1.0) -> TensorType:
+    """Computes the huber loss for a given term and delta parameter.
+
+    Reference: https://en.wikipedia.org/wiki/Huber_loss
+    Note that the factor of 0.5 is implicitly included in the calculation.
+
+    Formula:
+        L = 0.5 * x^2  for small abs x (delta threshold)
+        L = delta * (abs(x) - 0.5*delta)  for larger abs x (delta threshold)
+
+    Args:
+        x: The input term, e.g. a TD error.
+        delta: The delta parmameter in the above formula.
+
+    Returns:
+        The Huber loss resulting from `x` and `delta`.
+    """
+    return torch.where(
+        torch.abs(x) < delta,
+        torch.pow(x, 2.0) * 0.5,
+        delta * (torch.abs(x) - 0.5 * delta),
+    )
+
+
+@PublicAPI
+def l2_loss(x: TensorType) -> TensorType:
+    """Computes half the L2 norm over a tensor's values without the sqrt.
+
+    output = 0.5 * sum(x ** 2)
+
+    Args:
+        x: The input tensor.
+
+    Returns:
+        0.5 times the L2 norm over the given tensor's values (w/o sqrt).
+    """
+    return 0.5 * torch.sum(torch.pow(x, 2.0))
+
+
+@PublicAPI
+def minimize_and_clip(
+    optimizer: "torch.optim.Optimizer", clip_val: float = 10.0
+) -> None:
+    """Clips grads found in `optimizer.param_groups` to given value in place.
+
+    Ensures the norm of the gradients for each variable is clipped to
+    `clip_val`.
+
+    Args:
+        optimizer: The torch.optim.Optimizer to get the variables from.
+        clip_val: The global norm clip value. Will clip around -clip_val and
+            +clip_val.
+    """
+    # Loop through optimizer's variables and norm per variable.
+    for param_group in optimizer.param_groups:
+        for p in param_group["params"]:
+            if p.grad is not None:
+                torch.nn.utils.clip_grad_norm_(p.grad, clip_val)
+
+
+@PublicAPI
+def one_hot(x: TensorType, space: gym.Space) -> TensorType:
+    """Returns a one-hot tensor, given and int tensor and a space.
+
+    Handles the MultiDiscrete case as well.
+
+    Args:
+        x: The input tensor.
+        space: The space to use for generating the one-hot tensor.
+
+    Returns:
+        The resulting one-hot tensor.
+
+    Raises:
+        ValueError: If the given space is not a discrete one.
+
+    .. testcode::
+
+        import torch
+        import gymnasium as gym
+        from ray.rllib.utils.torch_utils import one_hot
+        x = torch.IntTensor([0, 3])  # batch-dim=2
+        # Discrete space with 4 (one-hot) slots per batch item.
+        s = gym.spaces.Discrete(4)
+        print(one_hot(x, s))
+        x = torch.IntTensor([[0, 1, 2, 3]])  # batch-dim=1
+        # MultiDiscrete space with 5 + 4 + 4 + 7 = 20 (one-hot) slots
+        # per batch item.
+        s = gym.spaces.MultiDiscrete([5, 4, 4, 7])
+        print(one_hot(x, s))
+
+    .. testoutput::
+
+        tensor([[1, 0, 0, 0],
+                [0, 0, 0, 1]])
+        tensor([[1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0]])
+    """
+    if isinstance(space, Discrete):
+        return nn.functional.one_hot(x.long(), space.n)
+    elif isinstance(space, MultiDiscrete):
+        if isinstance(space.nvec[0], np.ndarray):
+            nvec = np.ravel(space.nvec)
+            x = x.reshape(x.shape[0], -1)
+        else:
+            nvec = space.nvec
+        return torch.cat(
+            [nn.functional.one_hot(x[:, i].long(), n) for i, n in enumerate(nvec)],
+            dim=-1,
+        )
+    else:
+        raise ValueError("Unsupported space for `one_hot`: {}".format(space))
+
+
+@PublicAPI
+def reduce_mean_ignore_inf(x: TensorType, axis: Optional[int] = None) -> TensorType:
+    """Same as torch.mean() but ignores -inf values.
+
+    Args:
+        x: The input tensor to reduce mean over.
+        axis: The axis over which to reduce. None for all axes.
+
+    Returns:
+        The mean reduced inputs, ignoring inf values.
+    """
+    mask = torch.ne(x, float("-inf"))
+    x_zeroed = torch.where(mask, x, torch.zeros_like(x))
+    return torch.sum(x_zeroed, axis) / torch.sum(mask.float(), axis)
+
+
+@PublicAPI
+def sequence_mask(
+    lengths: TensorType,
+    maxlen: Optional[int] = None,
+    dtype=None,
+    time_major: bool = False,
+) -> TensorType:
+    """Offers same behavior as tf.sequence_mask for torch.
+
+    Thanks to Dimitris Papatheodorou
+    (https://discuss.pytorch.org/t/pytorch-equivalent-for-tf-sequence-mask/
+    39036).
+
+    Args:
+        lengths: The tensor of individual lengths to mask by.
+        maxlen: The maximum length to use for the time axis. If None, use
+            the max of `lengths`.
+        dtype: The torch dtype to use for the resulting mask.
+        time_major: Whether to return the mask as [B, T] (False; default) or
+            as [T, B] (True).
+
+    Returns:
+         The sequence mask resulting from the given input and parameters.
+    """
+    # If maxlen not given, use the longest lengths in the `lengths` tensor.
+    if maxlen is None:
+        maxlen = lengths.max()
+
+    mask = torch.ones(tuple(lengths.shape) + (int(maxlen),))
+
+    mask = ~(mask.to(lengths.device).cumsum(dim=1).t() > lengths)
+    # Time major transformation.
+    if not time_major:
+        mask = mask.t()
+
+    # By default, set the mask to be boolean.
+    mask.type(dtype or torch.bool)
+
+    return mask
+
+
+@PublicAPI
+def update_target_network(
+    main_net: NetworkType,
+    target_net: NetworkType,
+    tau: float,
+) -> None:
+    """Updates a torch.nn.Module target network using Polyak averaging.
+
+    new_target_net_weight = (
+        tau * main_net_weight + (1.0 - tau) * current_target_net_weight
+    )
+
+    Args:
+        main_net: The nn.Module to update from.
+        target_net: The target network to update.
+        tau: The tau value to use in the Polyak averaging formula.
+    """
+    # Get the current parameters from the Q network.
+    state_dict = main_net.state_dict()
+    # Use here Polyak averaging.
+    new_state_dict = {
+        k: tau * state_dict[k] + (1 - tau) * v
+        for k, v in target_net.state_dict().items()
+    }
+    # Apply the new parameters to the target Q network.
+    target_net.load_state_dict(new_state_dict)
+
+
+@DeveloperAPI
+def warn_if_infinite_kl_divergence(
+    policy: "TorchPolicy",
+    kl_divergence: TensorType,
+) -> None:
+    if policy.loss_initialized() and kl_divergence.isinf():
+        logger.warning(
+            "KL divergence is non-finite, this will likely destabilize your model and"
+            " the training process. Action(s) in a specific state have near-zero"
+            " probability. This can happen naturally in deterministic environments"
+            " where the optimal policy has zero mass for a specific action. To fix this"
+            " issue, consider setting the coefficient for the KL loss term to zero or"
+            " increasing policy entropy."
+        )
+
+
+@PublicAPI
+def set_torch_seed(seed: Optional[int] = None) -> None:
+    """Sets the torch random seed to the given value.
+
+    Args:
+        seed: The seed to use or None for no seeding.
+    """
+    if seed is not None and torch:
+        torch.manual_seed(seed)
+        # See https://github.com/pytorch/pytorch/issues/47672.
+        cuda_version = torch.version.cuda
+        if cuda_version is not None and float(torch.version.cuda) >= 10.2:
+            os.environ["CUBLAS_WORKSPACE_CONFIG"] = "4096:8"
+        else:
+            # Not all Operations support this.
+            torch.use_deterministic_algorithms(True)
+        # This is only for Convolution no problem.
+        torch.backends.cudnn.deterministic = True
+
+
+@PublicAPI
+def softmax_cross_entropy_with_logits(
+    logits: TensorType,
+    labels: TensorType,
+) -> TensorType:
+    """Same behavior as tf.nn.softmax_cross_entropy_with_logits.
+
+    Args:
+        x: The input predictions.
+        labels: The labels corresponding to `x`.
+
+    Returns:
+        The resulting softmax cross-entropy given predictions and labels.
+    """
+    return torch.sum(-labels * nn.functional.log_softmax(logits, -1), -1)
+
+
+def _dynamo_is_available():
+    # This only works if torch._dynamo is available
+    try:
+        # TODO(Artur): Remove this once torch._dynamo is available on CI
+        import torch._dynamo as dynamo  # noqa: F401
+
+        return True
+    except ImportError:
+        return False

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/typing.py

@@ -0,0 +1,310 @@
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Hashable,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
+
+import numpy as np
+import gymnasium as gym
+
+from ray.rllib.utils.annotations import OldAPIStack
+
+if TYPE_CHECKING:
+    from ray.rllib.core.rl_module.rl_module import RLModuleSpec
+    from ray.rllib.core.rl_module.multi_rl_module import MultiRLModuleSpec
+    from ray.rllib.env.env_context import EnvContext
+    from ray.rllib.env.multi_agent_episode import MultiAgentEpisode
+    from ray.rllib.env.single_agent_episode import SingleAgentEpisode
+    from ray.rllib.policy.dynamic_tf_policy_v2 import DynamicTFPolicyV2
+    from ray.rllib.policy.eager_tf_policy_v2 import EagerTFPolicyV2
+    from ray.rllib.policy.policy import PolicySpec
+    from ray.rllib.policy.sample_batch import MultiAgentBatch, SampleBatch
+    from ray.rllib.policy.view_requirement import ViewRequirement
+    from ray.rllib.utils import try_import_jax, try_import_tf, try_import_torch
+
+    _, tf, _ = try_import_tf()
+    torch, _ = try_import_torch()
+    jax, _ = try_import_jax()
+    jnp = None
+    if jax is not None:
+        jnp = jax.numpy
+
+# Represents a generic tensor type.
+# This could be an np.ndarray, tf.Tensor, or a torch.Tensor.
+TensorType = Union[np.array, "jnp.ndarray", "tf.Tensor", "torch.Tensor"]
+
+# Either a plain tensor, or a dict or tuple of tensors (or StructTensors).
+TensorStructType = Union[TensorType, dict, tuple]
+
+# A shape of a tensor.
+TensorShape = Union[Tuple[int], List[int]]
+
+# A neural network
+NetworkType = Union["torch.nn.Module", "tf.keras.Model"]
+
+# An RLModule spec (single-agent or multi-agent).
+RLModuleSpecType = Union["RLModuleSpec", "MultiRLModuleSpec"]
+
+# A state dict of an RLlib component (e.g. EnvRunner, Learner, RLModule).
+StateDict = Dict[str, Any]
+
+# Represents a fully filled out config of a Algorithm class.
+# Note: Policy config dicts are usually the same as AlgorithmConfigDict, but
+# parts of it may sometimes be altered in e.g. a multi-agent setup,
+# where we have >1 Policies in the same Algorithm.
+AlgorithmConfigDict = dict  # @OldAPIStack
+
+# An algorithm config dict that only has overrides. It needs to be combined with
+# the default algorithm config to be used.
+PartialAlgorithmConfigDict = dict  # @OldAPIStack
+
+# Represents the model config sub-dict of the algo config that is passed to
+# the model catalog.
+ModelConfigDict = dict  # @OldAPIStack
+
+# Conv2D configuration format.
+# Each entry in the outer list represents one Conv2D layer.
+# Each inner list has the format: [num_output_filters, kernel, stride], where kernel
+# and stride may be single ints (width and height are the same) or 2-tuples (int, int)
+# for width and height (different values).
+ConvFilterSpec = List[
+    Tuple[int, Union[int, Tuple[int, int]], Union[int, Tuple[int, int]]]
+]
+
+# Objects that can be created through the `from_config()` util method
+# need a config dict with a "type" key, a class path (str), or a type directly.
+FromConfigSpec = Union[Dict[str, Any], type, str]
+
+# Represents the env_config sub-dict of the algo config that is passed to
+# the env constructor.
+EnvConfigDict = dict
+
+# Represents an environment id. These could be:
+# - An int index for a sub-env within a vectorized env.
+# - An external env ID (str), which changes(!) each episode.
+EnvID = Union[int, str]
+
+# Represents a BaseEnv, MultiAgentEnv, ExternalEnv, ExternalMultiAgentEnv,
+# VectorEnv, gym.Env, or ActorHandle.
+# TODO (sven): Specify this type more strictly (it should just be gym.Env).
+EnvType = Union[Any, gym.Env]
+
+# A callable, taking a EnvContext object
+# (config dict + properties: `worker_index`, `vector_index`, `num_workers`,
+# and `remote`) and returning an env object (or None if no env is used).
+EnvCreator = Callable[["EnvContext"], Optional[EnvType]]
+
+# Represents a generic identifier for an agent (e.g., "agent1").
+AgentID = Any
+
+# Represents a generic identifier for a policy (e.g., "pol1").
+PolicyID = str  # @OldAPIStack
+# Represents a generic identifier for a (single-agent) RLModule.
+ModuleID = str
+
+# Type of the config.policies dict for multi-agent training.
+MultiAgentPolicyConfigDict = Dict[PolicyID, "PolicySpec"]  # @OldAPIStack
+
+# A new stack Episode type: Either single-agent or multi-agent.
+EpisodeType = Union["SingleAgentEpisode", "MultiAgentEpisode"]
+
+# Is Policy to train callable.
+# @OldAPIStack
+IsPolicyToTrain = Callable[[PolicyID, Optional["MultiAgentBatch"]], bool]
+
+# Agent to module mapping and should-module-be-updated.
+AgentToModuleMappingFn = Callable[[AgentID, EpisodeType], ModuleID]
+ShouldModuleBeUpdatedFn = Union[
+    Sequence[ModuleID],
+    Callable[[ModuleID, Optional["MultiAgentBatch"]], bool],
+]
+
+# State dict of a Policy, mapping strings (e.g. "weights") to some state
+# data (TensorStructType).
+PolicyState = Dict[str, TensorStructType]  # @OldAPIStack
+
+# Any tf Policy type (static-graph or eager Policy).
+TFPolicyV2Type = Type[Union["DynamicTFPolicyV2", "EagerTFPolicyV2"]]  # @OldAPIStack
+
+# Represents an episode id (old and new API stack).
+EpisodeID = Union[int, str]
+
+# Represents an "unroll" (maybe across different sub-envs in a vector env).
+UnrollID = int  # @OldAPIStack
+
+# A dict keyed by agent ids, e.g. {"agent-1": value}.
+MultiAgentDict = Dict[AgentID, Any]
+
+# A dict keyed by env ids that contain further nested dictionaries keyed by
+# agent ids. e.g., {"env-1": {"agent-1": value}}.
+MultiEnvDict = Dict[EnvID, MultiAgentDict]
+
+# Represents an observation returned from the env.
+EnvObsType = Any
+
+# Represents an action passed to the env.
+EnvActionType = Any
+
+# Info dictionary returned by calling `reset()` or `step()` on `gymnasium.Env`
+# instances. Might be an empty dict.
+EnvInfoDict = dict
+
+# Represents a File object
+FileType = Any
+
+# Represents a ViewRequirements dict mapping column names (str) to
+# ViewRequirement objects.
+ViewRequirementsDict = Dict[str, "ViewRequirement"]  # @OldAPIStack
+
+# Represents the result dict returned by Algorithm.train() and algorithm components,
+# such as EnvRunners, LearnerGroup, etc.. Also, the MetricsLogger used by all these
+# components returns this upon its `reduce()` method call, so a ResultDict can further
+# be accumulated (and reduced again) by downstream components.
+ResultDict = Dict
+
+# A tf or torch local optimizer object.
+LocalOptimizer = Union["torch.optim.Optimizer", "tf.keras.optimizers.Optimizer"]
+Optimizer = LocalOptimizer
+Param = Union["torch.Tensor", "tf.Variable"]
+ParamRef = Hashable
+ParamDict = Dict[ParamRef, Param]
+ParamList = List[Param]
+
+# A single learning rate or a learning rate schedule (list of sub-lists, each of
+# the format: [ts (int), lr_to_reach_by_ts (float)]).
+LearningRateOrSchedule = Union[
+    float,
+    List[List[Union[int, float]]],
+    List[Tuple[int, Union[int, float]]],
+]
+
+# Dict of tensors returned by compute gradients on the policy, e.g.,
+# {"td_error": [...], "learner_stats": {"vf_loss": ..., ...}}, for multi-agent,
+# {"policy1": {"learner_stats": ..., }, "policy2": ...}.
+GradInfoDict = dict
+
+# Dict of learner stats returned by compute gradients on the policy, e.g.,
+# {"vf_loss": ..., ...}. This will always be nested under the "learner_stats"
+# key(s) of a GradInfoDict. In the multi-agent case, this will be keyed by
+# policy id.
+LearnerStatsDict = dict
+
+# List of grads+var tuples (tf) or list of gradient tensors (torch)
+# representing model gradients and returned by compute_gradients().
+ModelGradients = Union[List[Tuple[TensorType, TensorType]], List[TensorType]]
+
+# Type of dict returned by get_weights() representing model weights.
+ModelWeights = dict
+
+# An input dict used for direct ModelV2 calls.
+ModelInputDict = Dict[str, TensorType]
+
+# Some kind of sample batch.
+SampleBatchType = Union["SampleBatch", "MultiAgentBatch", Dict[str, Any]]
+
+# A (possibly nested) space struct: Either a gym.spaces.Space or a
+# (possibly nested) dict|tuple of gym.space.Spaces.
+SpaceStruct = Union[gym.spaces.Space, dict, tuple]
+
+# A list of batches of RNN states.
+# Each item in this list has dimension [B, S] (S=state vector size)
+StateBatches = List[List[Any]]  # @OldAPIStack
+
+# Format of data output from policy forward pass.
+# __sphinx_doc_begin_policy_output_type__
+PolicyOutputType = Tuple[TensorStructType, StateBatches, Dict]  # @OldAPIStack
+# __sphinx_doc_end_policy_output_type__
+
+
+# __sphinx_doc_begin_agent_connector_data_type__
+@OldAPIStack
+class AgentConnectorDataType:
+    """Data type that is fed into and yielded from agent connectors.
+
+    Args:
+        env_id: ID of the environment.
+        agent_id: ID to help identify the agent from which the data is received.
+        data: A payload (``data``). With RLlib's default sampler, the payload
+            is a dictionary of arbitrary data columns (obs, rewards, terminateds,
+            truncateds, etc).
+    """
+
+    def __init__(self, env_id: str, agent_id: str, data: Any):
+        self.env_id = env_id
+        self.agent_id = agent_id
+        self.data = data
+
+
+# __sphinx_doc_end_agent_connector_data_type__
+
+
+# __sphinx_doc_begin_action_connector_output__
+@OldAPIStack
+class ActionConnectorDataType:
+    """Data type that is fed into and yielded from agent connectors.
+
+    Args:
+        env_id: ID of the environment.
+        agent_id: ID to help identify the agent from which the data is received.
+        input_dict: Input data that was passed into the policy.
+            Sometimes output must be adapted based on the input, for example
+            action masking. So the entire input data structure is provided here.
+        output: An object of PolicyOutputType. It is is composed of the
+            action output, the internal state output, and additional data fetches.
+
+    """
+
+    def __init__(
+        self,
+        env_id: str,
+        agent_id: str,
+        input_dict: TensorStructType,
+        output: PolicyOutputType,
+    ):
+        self.env_id = env_id
+        self.agent_id = agent_id
+        self.input_dict = input_dict
+        self.output = output
+
+
+# __sphinx_doc_end_action_connector_output__
+
+
+# __sphinx_doc_begin_agent_connector_output__
+@OldAPIStack
+class AgentConnectorsOutput:
+    """Final output data type of agent connectors.
+
+    Args are populated depending on the AgentConnector settings.
+    The branching happens in ViewRequirementAgentConnector.
+
+    Args:
+        raw_dict: The raw input dictionary that sampler can use to
+            build episodes and training batches.
+            This raw dict also gets passed into ActionConnectors in case
+            it contains data useful for action adaptation (e.g. action masks).
+        sample_batch: The SampleBatch that can be immediately used for
+            querying the policy for next action.
+    """
+
+    def __init__(
+        self, raw_dict: Dict[str, TensorStructType], sample_batch: "SampleBatch"
+    ):
+        self.raw_dict = raw_dict
+        self.sample_batch = sample_batch
+
+
+# __sphinx_doc_end_agent_connector_output__
+
+
+# Generic type var.
+T = TypeVar("T")

janus/lib/libasan.so.6.0.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2a8a7995a4d84a8817af8d1604bef621e99d0622df4eda14f6fe5245735a952e
+size 7575272

janus/lib/libgcc_s.so.1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d912bad5e511194c15b506fe7eafe4454bc2dc4073a0fdebc60e86af59a0f2bc
+size 475272

janus/lib/libssl.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3480c91df4e0c1a33514955568641405e37924f680e8ba42f494a209640516c6
+size 775712

janus/lib/libstdc++.so.6.0.29

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f045231ff3a95c2fbfde450575f0ef45d23e95be15193c8729b521fc363ece4
+size 17981480

janus/lib/tcl8.6/encoding/cns11643.enc

@@ -0,0 +1,1584 @@
+# Encoding file: cns11643, double-byte
+D
+2134 0 93
+21
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00004E284E364E3F4E854E054E04518251965338536953B64E2A4E874E4951E2
+4E464E8F4EBC4EBE516651E35204529C53B95902590A5B805DDB5E7A5E7F5EF4
+5F505F515F61961D4E3C4E634E624EA351854EC54ECF4ECE4ECC518451865722
+572351E45205529E529D52FD5300533A5C735346535D538653B7620953CC6C15
+53CE57216C3F5E005F0C623762386534653565E04F0E738D4E974EE04F144EF1
+4EE74EF74EE64F1D4F024F054F2256D8518B518C519951E55213520B52A60000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+22
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000053225304530353075407531E535F536D538953BA53D0598053F653F753F9
+597E53F4597F5B565724590459185932593059345DDF59755E845B825BF95C14
+5FD55FD45FCF625C625E626462615E815E835F0D5F52625A5FCA5FC7623965EE
+624F65E7672F6B7A6C39673F673C6C376C446C45738C75927676909390926C4B
+6C4C4E214E204E224E684E894E984EF94EEF7F5182784EF84F064F034EFC4EEE
+4F1690994F284F1C4F074F1A4EFA4F17514A962351724F3B51B451B351B20000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+23
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00004F6451E84F675214520F5215521852A84F33534B534F518F5350521C538B
+522153BE52AE53D2541653FF538E540054305405541354155445541956E35735
+57365731573258EE59054E545447593656E756E55741597A574C5986574B5752
+5B865F535C1859985C3D5C78598E59A25990598F5C8059A15E085B925C285C2A
+5C8D5EF55F0E5C8B5C895C925FD35FDA5C935FDB5DE0620F625D625F62676257
+9F505E8D65EB65EA5F7867375FD2673267366B226BCE5FEE6C586C516C770000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+24
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006C3C5FFA6C5A5FF76C53706F7072706E6283628C707372B172B26287738F
+627B627A6270793C6288808D808E6272827B65F08D718FB99096909A67454E24
+4E7167554E9C4F454F4A4F394F37674B4F324F426C1A4F444F4B6C6B4F404F35
+4F3151516C6F5150514E6C6D6C87519D6C9C51B551B851EC522352275226521F
+522B522052B452B372C65325533B537473957397739373947392544D75397594
+543A7681793D5444544C5423541A5432544B5421828F54345449545054220000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+25
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000543F5451545A542F8FC956E956F256F356EF56ED56EC56E6574896285744
+573F573C575357564F85575F5743575857574F744F894F8457464F4C573D4F6A
+57425754575558F158F258F0590B9EA656F1593D4F955994598C519E599C51BE
+5235599F5233599B52315989599A530B658853925B8D54875BFE5BFF5BFD5C2B
+54885C845C8E5C9C5465546C5C855DF55E09546F54615E0B54985E925E905F03
+56F75F1E5F6357725FE75FFE5FE65FDC5FCE57805FFC5FDF5FEC5FF657620000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+26
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005FF25FF05FF95945621359BA59CF623B623C628259C159B659BC6278628B
+59B1629E62A5629B629C6299628D6285629D62755C445C475CAE65F65CA05CB5
+5CAF66F5675B5C9F675467525CA267586744674A67615CB66C7F6C916C9E5E14
+6C6E6C7C6C9F6C755F246C566CA26C795F7D6CA15FE56CAA6CA0601970797077
+707E600A7075707B7264601E72BB72BC72C772B972BE72B66011600C7398601C
+6214623D62AD7593768062BE768376C076C162AE62B377F477F562A97ACC0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+27
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00007ACD7CFA809F80918097809466048286828C65FB8295660B866C66058FB5
+8FBE8FC766F68FC190A990A4678E6792677690A896279626962B963396349629
+4E3D679F4E9D4F934F8A677D67814F6D4F8E4FA04FA24FA14F9F4FA36C1D4F72
+6CEC4F8C51566CD96CB651906CAD6CE76CB751ED51FE522F6CC3523C52345239
+52B952B552BF53556C9D5376537A53936D3053C153C253D554856CCF545F5493
+548954799EFE548F5469546D70915494546A548A708356FD56FB56F872D80000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+28
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000056FC56F6576557815763576772D1576E5778577F73A673A258F3594B594C
+74DD74E8753F59AD753E59C4759859C259B076F176F076F577F859BF77F959C9
+59B859AC7942793F79C559B759D77AFB5B607CFD5B965B9E5B945B9F5B9D80B5
+5C005C1982A082C05C495C4A82985CBB5CC182A782AE82BC5CB95C9E5CB45CBA
+5DF65E135E125E7782C35E9882A25E995E9D5EF8866E5EF98FD25F065F218FCD
+5F255F558FD790B290B45F845F8360306007963D6036963A96434FCD5FE90000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+29
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000603D60084FC94FCB62BA62B24FDC62B762E462A74FDB4FC74FD662D562E1
+62DD62A662C162C562C062DF62E062DE53976589539965A665BA54A165FF54A5
+66176618660165FE54AE670C54B6676B67966782678A54BC67A354BE67A2678F
+54B067F967806B266B276B686B69579D6B816BB46BD1578F57996C1C579A5795
+58F4590D59536C976C6C6CDF5A006CEA59DD6CE46CD86CB26CCE6CC859F2708B
+70887090708F59F570877089708D70815BA8708C5CD05CD872405CD75CCB0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+2A
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00007265726672685CC95CC772CD72D372DB5CD472CF73A773A3739E5CDF73AF
+5DF95E2173AA739C5E2075427544753B75415E9B759B759E5F0779C479C379C6
+6037603979C7607279CA604560537ACF7C767C747CFF7CFC6042605F7F5980A8
+6058606680B0624280B362CF80A480B680A780AC630380A65367820E82C4833E
+829C63006313631462FA631582AA62F082C9654365AA82A682B2662166326635
+8FCC8FD98FCA8FD88FCF90B7661D90AD90B99637670F9641963E96B697510000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+2B
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000097634E574E794EB24EB04EAF4EB14FD24FD567E44FBE4FB84FB04FB14FC8
+67F667EE4FC64FCC4FE54FE34FB4516A67B2519F67C651C167CC51C251C35245
+524867C967CA524F67EA67CB52C552CA52C453275358537D6BE053DD53DC53DA
+53D954B96D1F54D054B454CA6D0A54A354DA54A46D1954B2549E549F54B56D1D
+6D4254CD6D1854CC6D03570057AC5791578E578D579257A1579057A657A8709F
+579C579657A770A170B470B570A958F572495909590872705952726E72CA0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+2C
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000059DF72E859EB59EF59F059D55A0D5A0459F95A0259F859E259D959E75B6A
+73B473EB5BAB73C75C1B5C2F73C6663C73CB74EC74EE5CD15CDC5CE65CE15CCD
+76795CE25CDD5CE55DFB5DFA5E1E76F75EA176FA77E75EFC5EFB5F2F78127805
+5F66780F780E7809605C7813604E6051794B794560236031607C605279D66060
+604A60617AD162187B017C7A7C787C797C7F7C807C81631F631762EA63216304
+63057FBE6531654465408014654265BE80C76629661B80C86623662C661A0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+2D
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006630663B661E6637663880C9670E80D780E667E867D6822167C767BC6852
+67BF67D567FE836367FB833A67B168016805680067D782F26B2A6B6B82FB82F6
+82F082EA6BE182E082FA6D236CFF6D146D056D136D066D21884E6D156CAF6CF4
+6D026D458A076D268FE36D448FEE6D2470A590BD70A390D570A270BB70A070AA
+90C891D470A870B670B270A79653964A70B9722E5005723C5013726D5030501B
+72E772ED503372EC72E572E24FF773C473BD73CF73C973C173D0503173CE0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+2E
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000074ED74EB519374EF754975507546754A5261754D75A6525E525F525575A8
+52CD530E76C776FF54E276FD77E6780A54F37804780B78075504781578085511
+79D379D479D079D77A7C54F854E07A7D7A837A8257017AD47AD57AD37AD07AD2
+7AFE7AFC7C777C7C7C7B57B657BF57C757D057B957C1590E594A7F8F80D35A2D
+80CB80D25A0F810980E280DF80C65B6C822482F782D882DD5C565C5482F882FC
+5CEE5CF182E95D0082EE5E2982D0830E82E2830B82FD517986765F6786780000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+2F
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000605A60678675867D6088884288666081898C8A0560958A0660978C9F609C
+8FF18FE78FE98FEF90C290BC632C90C690C06336634390CD90C9634B90C4633C
+958163419CEC50324FF9501D4FFF50044FF05003635150024FFC4FF250245008
+5036502E65C35010503850394FFD50564FFB51A351A651A1681A684951C751C9
+5260526452595265526752575263682B5253682F52CF684452CE52D052D152CC
+68266828682E550D54F46825551354EF54F554F9550255006B6D808255180000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+30
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000054F054F66BE86BE355196BE7570557C96D6357B757CD6D0D6D616D9257BE
+57BB6D6D57DB57C857C457C557D157CA57C06D676D605A215A2A6D7C5A1D6D82
+5A0B6D2F6D686D8B6D7E5A226D846D165A246D7B5A145A316D905A2F5A1A5A12
+70DD70CB5A2670E270D75BBC5BBB5BB75C055C065C525C5370C770DA5CFA5CEB
+72425CF35CF55CE95CEF72FA5E2A5E305E2E5E2C5E2F5EAF5EA973D95EFD5F32
+5F8E5F935F8F604F609973D2607E73D46074604B6073607573E874DE60560000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+31
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000060A9608B60A6755B609360AE609E60A7624575C075BF632E75BA63526330
+635B771B6319631B77126331635D6337633563537722635C633F654B78227835
+658B7828659A66506646664E6640782A664B6648795B66606644664D79526837
+682479EC79E0681B683679EA682C681968566847683E681E7A8B681568226827
+685968586855683068236B2E6B2B6B306B6C7B096B8B7C846BE96BEA6BE56D6B
+7C8D7C856D736D577D117D0E6D5D6D566D8F6D5B6D1C6D9A6D9B6D997F610000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+32
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006D816D717F5D7F5B6D726D5C6D9670C470DB70CC70D070E370DF80F270D6
+70EE70D580FB81008201822F727A833372F573028319835173E273EC73D573F9
+73DF73E683228342834E831B73E473E174F3834D831683248320755675557558
+7557755E75C38353831E75B4834B75B18348865376CB76CC772A86967716770F
+869E8687773F772B770E772486857721771877DD86A7869578247836869D7958
+79598843796279DA79D9887679E179E579E879DB886F79E279F08874887C0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+33
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00008A128C477ADA7ADD8CA47ADB7ADC8D788DB57B0D7B0B7B147C8E7C868FF5
+7C877C837C8B90048FFC8FF690D67D2490D990DA90E37D257F627F937F997F97
+90DC90E47FC47FC6800A91D591E28040803C803B80F680FF80EE810481038107
+506A506180F750605053822D505D82278229831F8357505B504A506250158321
+505F506983188358506450465040506E50738684869F869B868986A68692868F
+86A0884F8878887A886E887B88848873555055348A0D8A0B8A19553655350000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+34
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000553055525545550C8FF990099008553990DE9151553B554091DB91DF91DE
+91D691E095859660965957F4965657ED57FD96BD57F8580B5042505958075044
+50665052505450715050507B507C505857E758015079506C507851A851D151CF
+5268527652D45A5553A053C45A385558554C55685A5F55495A6C5A53555D5529
+5A43555455535A44555A5A48553A553F552B57EA5A4C57EF5A695A4757DD57FE
+5A4257DE57E65B6E57E857FF580358F768A6591F5D1A595B595D595E5D0D0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+35
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005D265A2B5D0F5A3B5D125D235A615A3A5A6E5A4B5A6B5EB45EB95A455A4E
+5A685A3D5A715A3F5A6F5A7560905A735A2C5A595A545A4F5A6360CF60E45BC8
+60DD5BC360B15C5B5C6160CA5D215D0A5D0960C05D2C5D08638A63825D2A5D15
+639E5D105D1363975D2F5D18636F5DE35E395E355E3A5E32639C636D63AE637C
+5EBB5EBA5F345F39638563816391638D6098655360D066656661665B60D760AA
+666260A160A4688760EE689C60E7686E68AE60DE6956686F637E638B68A90000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+36
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000687563796386639368776373636A686B636C68AA637F687163B263BA6896
+688B6366637468A4655A687B654E654D658D658E65AD6B3365C765CA6B9165C9
+6B8D65E366576C2A66636667671A671967166DAC6DE9689E68B6689868736E00
+689A688E68B768DB68A5686C68C168846DDB6DF46895687A68996DF068B868B9
+68706DCF6B356DD06B906BBB6BED6DD76DCD6DE36DC16DC36DCE70F771176DAD
+6E0470F06DB970F36DE770FC6E086E0671136E0A6DB070F66DF86E0C710E0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+37
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006DB1727B6E026E076E096E016E176DFF6E12730A730871037107710170F5
+70F1710870F2710F740170FE7407740073FA731A7310730E740273F374087564
+73FB75CE75D275CF751B752375617568768F756775D37739772F769077317732
+76D576D776D67730773B7726784877407849771E784A784C782678477850784B
+7851784F78427846796B796E796C79F279F879F179F579F379F97A907B357B3B
+7A9A7A937A917AE17B247B337B217B1C7B167B177B367B1F7B2F7C937C990000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+38
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00007C9A7C9C7C947D497C967D347D377D3D7D2D7D367D4C7D457D2C7D487D41
+7D477F3B7D3F7D4A7D3B7D288008801A7F9C801D7F9B8049804580447C9B7FD1
+7FC7812A812E801F801E81318047811A8134811781258119811B831D83718384
+8380837283A18127837983918211839F83AD823A8234832382748385839C83B7
+8658865A8373865786B2838F86AE8395839983758845889C889488A3888F88A5
+88A988A6888A88A0889089928991899483B08A268A328A2883AE83768A1C0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+39
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000086568A2B8A2086C28A2986C586BA86B08A218C3A86B38C5B8C588C7C86BB
+8CA68CAE8CAD8D6588528D7E88958D7C8D7F8D7A8DBD889188A18DC08DBB8EAD
+8EAF8ED6889788A488AC888C88938ED9898289D69012900E90258A27901390EE
+8C3990AB90F78C5D9159915491F291F091E591F68DC28DB995878DC1965A8EDE
+8EDD966E8ED78EE08EE19679900B98E198E6900C9EC49ED24E8090F04E81508F
+50975088508990EC90E950815160915A91535E4251D391F491F151D251D60000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+3A
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000527391F9527091EB91F791E853A853A653C5559755DE966D966B559655B4
+96BF55859804559B55A0509B555950945586508B50A355AF557A508E509D5068
+559E509255A9570F570E581A5312581F53A4583C5818583E582655AD583A5645
+5822559358FB5963596455815AA85AA35A825A885AA15A855A9855955A99558E
+5A895A815A965A80581E58275A91582857F5584858255ACF581B5833583F5836
+582E58395A875AA0582C5A7959615A865AAB5AAA5AA45A8D5A7E5A785BD50000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+3B
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005A7C5AA55AAC5C1E5C5F5C5E5D445D3E5A975D485D1C5AA95D5B5D4D5A8C
+5A9C5D575A935D535D4F5BCD5D3B5D465BD15BCA5E465E475C305E485EC05EBD
+5EBF5D4B5F115D355F3E5F3B5D555F3A5D3A5D525D3D5FA75D5960EA5D396107
+6122610C5D325D3660B360D660D25E4160E360E560E95FAB60C9611160FD60E2
+60CE611E61206121621E611663E263DE63E660F860FC60FE60C163F8611863FE
+63C163BF63F763D1655F6560656163B063CE65D163E863EF667D666B667F0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+3C
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000063CA63E066736681666D6669646163DF671E68ED63DC63C463D863D36903
+63C768FE68E5691E690263D763D9690968CA690065646901691868E268CF659D
+692E68C568FF65D2691C68C3667B6B6F66716B6E666A6BBE67016BF46C2D6904
+6DB66E756E1E68EA6E18690F6E4868F76E4F68E46E426E6A6E706DFE68E16907
+6E6D69086E7B6E7E6E5968EF6E5769146E806E5068FD6E296E766E2A6E4C712A
+68CE7135712C7137711D68F468D1713868D47134712B7133712771246B3B0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+3D
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000712D7232728372827287730673247338732A732C732B6DFC732F73287417
+6E496E88741974386E45741F7414743C73F7741C74157418743974F975246E51
+6E3B6E03756E756D7571758E6E6175E56E286E606E716E6B769476B36E3076D9
+6E657748774977436E776E55774277DF6E66786378766E5A785F786679667971
+712E713179767984797579FF7A0771287A0E7A09724B725A7288728972867285
+7AE77AE27B55733073227B437B577B6C7B427B5373267B417335730C7CA70000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+3E
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00007CA07CA67CA47D74741A7D59742D7D607D577D6C7D7E7D6474207D5A7D5D
+752F756F756C7D767D4D7D7575E67FD37FD675E475D78060804E8145813B7747
+814881428149814081148141774C81EF81F68203786483ED785C83DA841883D2
+8408787084007868785E786284178346841483D38405841F8402841683CD83E6
+7AE6865D86D586E17B447B487B4C7B4E86EE884788467CA27C9E88BB7CA188BF
+88B47D6388B57D56899A8A437D4F7D6D8A5A7D6B7D527D548A358A388A420000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+3F
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00008A498A5D8A4B8A3D7F667FA27FA07FA18C608C5E8C7F8C7E8C8380D48CB1
+8D878152814F8D888D83814D813A8D868D8B8D828DCA8DD28204823C8DD48DC9
+8EB0833B83CF83F98EF28EE48EF38EEA83E78EFD83FC8F9D902B902A83C89028
+9029902C840183DD903A90309037903B83CB910A83D683F583C991FE922083DE
+920B84069218922283D5921B920883D1920E9213839A83C3959583EE83C483FB
+968C967B967F968183FE968286E286E686D386E386DA96EE96ED86EB96EC0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+40
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000975F976F86D7976D86D188488856885588BA88D798F088B888C088BE9AA9
+88BC88B79AE04EB7890188C950CC50BC899750AA50B989DB50AB50C350CD517E
+527E52798A588A4452E152E052E7538053AB53AA53A953E055EA8C8055D78CBE
+8CB055C157158D84586C8D89585C58505861586A5869585658605866585F5923
+596659688EEF8EF75ACE8EF95AC55AC38EE58EF55AD08EE88EF68EEB8EF18EEC
+8EF45B745B765BDC5BD75BDA5BDB91045C205D6D5D6690F95D645D6E91000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+41
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005D605F425F5A5F6E9164915F6130613A612A614361196131921A613D920F
+920C92006408643264389206643192276419921C6411921992176429641D957B
+958D958C643C96876446644796899683643A640796C8656B96F16570656D9770
+65E4669398A998EB9CE69EF9668F4E844EB6669250BF668E50AE694650CA50B4
+50C850C250B050C150BA693150CB50C9693E50B8697C694352786973527C6955
+55DB55CC6985694D69506947696769366964696155BF697D6B446B406B710000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+42
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006B736B9C55C855F255CD6BC155C26BFA6C316C325864584F6EB86EA8586F
+6E916EBB585D6E9A5865585B6EA9586358716EB56E6C6EE85ACB6EDD6EDA6EE6
+6EAC5AB05ABF5AC86ED96EE36EE96EDB5ACA716F5AB65ACD71485A90714A716B
+5BD9714F715771745D635D4A5D6571457151716D5D6872517250724E5E4F7341
+5E4A732E73465EC574275EC674487453743D5FAF745D74566149741E74477443
+74587449612E744C7445743E61297501751E91686223757A75EE760276970000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+43
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00007698641064126409775D77647753775878827890788A6439787A787D6423
+788B787864306428788D788878927881797E798364256427640B7980641B642E
+64217A0F656F65927A1D66867AA17AA466907AE97AEA66997B627B6B67207B5E
+695F7B79694E69627B6F7B686945696A7CAE6942695769597CB069487D906935
+7D8A69337D8B7D997D9569787D877D787D977D897D986976695869417FA3694C
+693B694B7FDD8057694F8163816A816C692F697B693C815D81756B43815F0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+44
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006B48817D816D6BFB6BFC8241844F84846E9B847F6EC88448842A847B8472
+8464842E845C84536EC6844184C86EC184628480843E848384716EA6844A8455
+84586EC36EDC6ED886FC86FD87156E8D871686FF6EBF6EB36ED0885888CF88E0
+6EA371477154715289E78A6A8A80715D8A6F8A6571788A788A7D8A8871587143
+8A648A7E715F8A678C638C88714D8CCD724F8CC9728C8DED7290728E733C7342
+733B733A73408EB1734974448F048F9E8FA090439046904890459040904C0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+45
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000074427446910C9113911574FF916B9167925D9255923569839259922F923C
+928F925C926A9262925F926B926E923B92449241959A7699959976DD7755775F
+968F77529696775A7769776796F496FC776D9755788797797894788F788497EE
+97F57886980B788398F37899788098F798FF98F5798298EC98F17A117A18999A
+7A129AE29B3D9B5D9CE87A1B9CEB9CEF9CEE9E819F1450D050D950DC50D87B69
+50E150EB7B737B7150F450E250DE7B767B637CB251F47CAF7D887D8652ED0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+46
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000052EA7D7F53327D7A53AE53B07D8355FB5603560B7D8456077D9255F87F6B
+5628561E7F6C5618561156515605571758928164588C817758785884587358AD
+58975895587758725896588D59108161596C82495AE782405AE4824584F15AEF
+5626847684795AF05D7B84655D83844084865D8B5D8C844D5D785E5284598474
+5ED05ECF85075FB35FB4843A8434847A617B8478616F6181613C614261386133
+844261606169617D6186622C62288452644C84C56457647C8447843664550000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+47
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000064626471646A6456643B6481846E644F647E646486F7870C86FA86D686F5
+657186F8870E66A5669A669C870D66A688D666A4698F69C569C8699269B288CC
+88D0898569E369C069D669D1699F69A269D289DC89E68A7669E169D5699D8A3F
+8A7769988A846B746BA18A816EF06EF38C3C8C4B6F1B6F0C6F1D6F346F286F17
+8C856F446F426F046F116EFA6F4A7191718E8D93718B718D717F718C717E717C
+71838DEE71888DE98DE372948DE773557353734F7354746C7465746674610000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+48
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000746B746874768F0B7460903F74747506760E91107607910F911176B99114
+76B776E2916E7774777777767775923A777877719265777A715B777B78A678AE
+78B8926C924F926078B178AF923679897987923192547A2992507A2A924E7A2D
+7A2C92567A32959F7AEC7AF07B817B9E7B8396917B9296CE7BA37B9F7B9396F5
+7B867CB87CB79772980F980D980E98AC7DC87DB699AF7DD199B07DA87DAB9AAB
+7DB37DCD9CED7DCF7DA49EFD50E67F417F6F7F7150F350DB50EA50DD50E40000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+49
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000050D38023805B50EF8061805F818152805281818482135330824A824C5615
+560C561284BD8495561C849284C35602849684A584B584B384A384E484D884D5
+589884B784AD84DA84938736587A58875891873D872B87478739587B8745871D
+58FE88FF88EA5AEE88F55AD5890088ED890388E95AF35AE289EA5ADB8A9B8A8E
+8AA25AD98A9C8A948A908AA98AAC5C638A9F5D805D7D8A9D5D7A8C675D775D8A
+8CD08CD68CD48D988D9A8D975D7F5E585E598E0B8E088E018EB48EB35EDC0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+4A
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00008FA18FA25ED2905A5F449061905F5FB6612C9125917B9176917C61739289
+92F692B192AD929292819284617A92AE9290929E616A6161615695A295A7622B
+642B644D645B645D96A0969D969F96D0647D96D1646664A6975964829764645C
+644B64539819645098149815981A646B645964656477990665A098F89901669F
+99BE99BC99B799B699C069C999B869CE699669B099C469BC99BF69999ADA9AE4
+9AE99AE89AEA9AE569BF9B2669BD69A49B4069B969CA699A69CF69B369930000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+4B
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000069AA9EBD699E69D969976990510E69B550F769C650FC510D510151DA51D9
+51DB5286528E52EE533353B16EF15647562D56546F37564B5652563156445656
+5650562B6F18564D5637564F58A258B76F7358B26EEE58AA58B558B06F3C58B4
+58A458A76F0E59265AFE6EFD5B046F395AFC6EFC5B065B0A5AFA5B0D5B005B0E
+7187719071895D9171855D8F5D905D985DA45D9B5DA35D965DE45E5A72957293
+5E5E734D5FB86157615C61A661956188747261A3618F75006164750361590000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+4C
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006178761661856187619E7611760A6198619C7781777C622F6480649B648E
+648D649464C678B264A8648378AD64B9648664B464AF649178A064AA64A164A7
+66B666B3798B66BC66AC799466AD6A0E79886A1C6A1A7A2B7A4A6A0B7A2F69EF
+6A0C69F06A227AAC69D87B886A1269FA7B916A2A7B966A107B8C7B9B6A2969F9
+69EA6A2C6A247BA469E96B526B4F6B537CBA7DA76F106F656F757DAA7DC17DC0
+7DC56FD07DCE6F5C6F3D6F717DCC6F916F0B6F796F816F8F7DA66F596F740000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+4D
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00007DA171AE7F7371A371AD7FE57FDE71AB71A671A2818952F2725772557299
+734B747A8215849784A4748C748484BA84CE74827493747B84AB750984B484C1
+84CD84AA849A84B1778A849D779084BB78C678D378C078D278C778C284AF799F
+799D799E84B67A4184A07A387A3A7A4284DB84B07A3E7AB07BAE7BB38728876B
+7BBF872E871E7BCD87197BB28743872C8741873E8746872087327CC47CCD7CC2
+7CC67CC37CC97CC787427DF887277DED7DE2871A873087117DDC7E027E010000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+4E
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000088F27DD688FE7DE47DFE88F67E007DFC7DFD88EB7DF57DFF899F7DEB7DE5
+7F787FAE7FE78A998065806A80668068806B819481A18192819681938D968E09
+85018DFF84F88DFD84F58E0385048E068E058DFE8E00851B85038533853484ED
+9123911C853591228505911D911A91249121877D917A91729179877192A5885C
+88E6890F891B92A089A989A589EE8AB1929A8ACC8ACE92978AB792A38AB58AE9
+8AB492958AB38AC18AAF8ACA8AD09286928C92998C8E927E92878CE98CDB0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+4F
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000928B8CEB8DA496A18DA28D9D977D977A977E97838E2A8E28977B97848EB8
+8EB68EB98EB78F228F2B8F278F198FA499078FB3999C9071906A99BB99BA9188
+918C92BF92B892BE92DC92E59B3F9B6092D492D69CF192DA92ED92F392DB5103
+92B992E292EB95AF50F695B295B3510C50FD510A96A396A552F152EF56485642
+970A563597879789978C97EF982A98225640981F563D9919563E99CA99DA563A
+571A58AB99DE99C899E058A39AB69AB558A59AF458FF9B6B9B699B729B630000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+50
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005AF69D0D5AF89D019D0C5B019CF85B055B0F9CFE9D029E845D9F9EAB9EAA
+511D51165DA0512B511E511B5290529453145E605E5C56675EDB567B5EE1565F
+5661618B6183617961B161B061A2618958C358CA58BB58C058C459015B1F5B18
+5B115B1561B35B125B1C64705B225B795DA664975DB35DAB5EEA648A5F5B64A3
+649F61B761CE61B961BD61CF61C06199619765B361BB61D061C4623166B764D3
+64C06A006A066A1769E564DC64D164C869E464D566C369EC69E266BF66C50000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+51
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000069FE66CD66C167066A1467246A636A426A5269E66A436A3369FC6A6C6A57
+6A046A4C6A6E6A0F69F66A266A0769F46A376B516A716A4A6A366BA66A536C00
+6A456A706F416F266A5C6B586B576F926F8D6F896F8C6F626F4F6FBB6F5A6F96
+6FBE6F6C6F826F556FB56FD36F9F6F576FB76FF571B76F0071BB6F6B71D16F67
+71BA6F5371B671CC6F7F6F9571D3749B6F6A6F7B749674A2749D750A750E719A
+7581762C76377636763B71A476A171AA719C779871B37796729A735873520000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+52
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000078D678EB736078DC735B79A579A998347A537A4574897A4F74867ABD7ABB
+7AF17488747C7BEC7BED7507757E7CD3761E7CE1761D7E197623761A76287E27
+7E26769D769E806E81AF778F778981AD78CD81AA821878CC78D178CE78D4856F
+854C78C48542799A855C8570855F79A2855A854B853F878A7AB4878B87A1878E
+7BBE7BAC8799885E885F892489A78AEA8AFD8AF98AE38AE57DDB7DEA8AEC7DD7
+7DE17E037DFA8CF27DF68CEF7DF08DA67DDF7F767FAC8E3B8E437FED8E320000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+53
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00008F318F307FE68F2D8F3C8FA78FA5819F819E819591379195918E82169196
+82539345930A824E825192FD9317931C930793319332932C9330930393058527
+95C284FB95B884FA95C1850C84F4852A96AB96B784F784EB97159714851284EA
+970C971784FE9793851D97D2850284FD983698319833983C982E983A84F0983D
+84F998B5992299239920991C991D866299A0876399EF99E899EB877387588754
+99E199E68761875A9AF89AF5876D876A9B839B949B84875D9B8B9B8F877A0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+54
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009B8C875C9B89874F9B8E8775876287679D249D0F89059D139D0A890B8917
+891889199D2A9D1A89119D279D169D2189A49E859EAC9EC69EC59ED79F538AB8
+5128512751DF8AD5533553B38ABE568A567D56898AC358CD58D08AD95B2B5B33
+5B295B355B315B375C365DBE8CDD5DB98DA05DBB8DA161E261DB61DD61DC61DA
+8E2E61D98E1B8E1664DF8E198E2664E18E1464EE8E1865B566D466D58E1A66D0
+66D166CE66D78F208F236A7D6A8A90736AA7906F6A996A826A88912B91290000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+55
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006A8691326A986A9D918591866A8F91816AAA91846B5D92D06C0A92C46FD7
+6FD66FE592CF92F192DF6FD96FDA6FEA92DD6FF692EF92C271E392CA71E992CE
+71EB71EF71F371EA92E092DE92E792D192D3737192E174AE92C674B3957C74AC
+95AB95AE75837645764E764476A376A577A677A4978A77A977AF97D097CF981E
+78F078F878F198287A49981B982798B27AC27AF27AF37BFA99167BF67BFC7C18
+7C087C1299D399D47CDB7CDA99D699D899CB7E2C7E4D9AB39AEC7F467FF60000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+56
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000802B807481B881C89B679B749B71859285939B75857F85AB85979B6C9CFC
+85AC9CFD9CFF9CF787CE9D0087CD9CFB9D0887C187B187C79ED389409F10893F
+893951178943511151DE533489AB56708B1F8B098B0C566656638C4056728C96
+56778CF68CF758C88E468E4F58BF58BA58C28F3D8F4193669378935D93699374
+937D936E93729373936293489353935F93685DB1937F936B5DB595C45DAE96AF
+96AD96B25DAD5DAF971A971B5E685E665E6F5EE9979B979F5EE85EE55F4B0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+57
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005FBC5FBB619D61A86196984061B4984761C198B761BA61BF61B8618C64D7
+99A264D064CF9A0099F3648964C399F564F364D99ABD9B009B0265A29B349B49
+9B9F66CA9BA39BCD9B999B9D66BA66CC9D396A349D446A496A679D356A686A3E
+9EAF6A6D512F6A5B6A519F8E6A5A569F569B569E5696569456A06A4F5B3B6A6F
+6A695B3A5DC15F4D5F5D61F36A4D6A4E6A466B5564F664E564EA64E765056BC8
+64F96C046C036C066AAB6AED6AB26AB06AB56ABE6AC16AC86FC46AC06ABC0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+58
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006AB16AC46ABF6FA56FAE700870036FFD7010700270136FA271FA720074B9
+74BC6FB2765B7651764F76EB77B871D677B977C177C077BE790B71C77907790A
+790871BC790D7906791579AF729E736973667AF5736C73657C2E736A7C1B749A
+7C1A7C24749274957CE67CE37580762F7E5D7E4F7E667E5B7F477FB476327630
+76BB7FFA802E779D77A181CE779B77A282197795779985CC85B278E985BB85C1
+78DE78E378DB87E987EE87F087D6880E87DA8948894A894E894D89B189B00000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+59
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000089B37AB78B388B327BE78B2D7BD58B347BDA8B298C747BD47BEA8D037BDC
+7BEB8DA98E587CD27CD48EBF8EC18F4A8FAC7E219089913D913C91A993A07E0E
+93907E159393938B93AD93BB93B87E0D7E14939C95D895D77F7B7F7C7F7A975D
+97A997DA8029806C81B181A6985481B99855984B81B0983F98B981B281B781A7
+81F29938993699408556993B993999A4855385619A089A0C85469A1085419B07
+85449BD285479BC29BBB9BCC9BCB854E856E9D4D9D639D4E85609D509D550000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+5A
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000855D9D5E85659E909EB29EB186649ECA9F029F279F26879356AF58E058DC
+87965B39877987875B7C5BF3879087915C6B5DC4650B6508650A8789891E65DC
+8930892D66E166DF6ACE6AD46AE36AD76AE2892C891F89F18AE06AD86AD56AD2
+8AF58ADD701E702C70256FF37204720872158AE874C474C974C774C876A977C6
+77C57918791A79208CF37A667A647A6A8DA78E338E3E8E388E408E457C357C34
+8E3D8E417E6C8E3F7E6E7E718F2E81D481D6821A82628265827685DB85D60000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+5B
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000908685E79133913585F4919387FD87D58807918F880F87F89308931F8987
+930F89B589F5933C8B3F8B438B4C93018D0B8E6B8E688E708E758E7792FA8EC3
+92F993E993EA93CB93C593C6932993ED93D3932A93E5930C930B93DB93EB93E0
+93C1931695BC95DD95BE95B995BA95B695BF95B595BD96A996D497B297B497B1
+97B597F2979497F097F89856982F98329924994499279A269A1F9A189A219A17
+99E49B0999E399EA9BC59BDF9AB99BE39AB49BE99BEE9AFA9AF99D669D7A0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+5C
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009B809D6E9D919D839D769D7E9D6D9B939E959EE39B7A9B959F039F049D25
+9F179D2051369D1453369D1D5B429D229D105B445B465B7E5DCA5DC85DCC5EF0
+9ED5658566E566E79F3D512651256AF451246AE9512952F45693568C568D703D
+56847036567E7216567F7212720F72177211720B5B2D5B2574CD74D074CC74CE
+74D15B2F75895B7B7A6F7C4B7C445E6C5E6A5FBE61C361B57E7F8B7161E0802F
+807A807B807C64EF64E964E385FC861086026581658085EE860366D2860D0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+5D
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000086138608860F881888126A9B6AA18967896589BB8B698B626A838B6E6AA4
+8B616A7F8B648B4D8C516A8C6A928E838EC66C09941F6FA99404941794089405
+6FED93F3941E9402941A941B9427941C71E196B571E871F2973371F097349731
+97B897BA749797FC74AB749098C374AD994D74A59A2F7510751175129AC97584
+9AC89AC49B2A9B389B5076E99C0A9BFB9C049BFC9BFE77B477B177A89C029BF6
+9C1B9BF99C159C109BFF9C009C0C78F978FE9D959DA579A87A5C7A5B7A560000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+5E
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009E989EC17A5A9F5A516456BB7C0558E65B495BF77BFF7BFB5DD07BF45FC2
+7BF365117C096AFF6AFE6AFD7BFD6B017BF07BF1704B704D704774D376687667
+7E33984877D179307932792E7E479F9D7AC97AC87E3B7C567C517E3A7F457F7F
+7E857E897E8E7E84802C826A862B862F862881C586168615861D881A825A825C
+858389BC8B758B7C85958D118D128F5C91BB85A493F4859E8577942D858985A1
+96E497379736976797BE97BD97E29868986698C898CA98C798DC8585994F0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+5F
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000099A99A3C85909A3B9ACE87BE9B149B5387C59C2E87AC9C1F87B587BC87AE
+87C99DB09DBD87CC87B79DAE9DC49E7B87B487B69E9E87B89F0587DE9F699FA1
+56C7571D5B4A5DD389525F72620289AD62356527651E651F8B1E8B186B076B06
+8B058B0B7054721C72207AF88B077C5D7C588B067E927F4E8B1A8C4F8C708827
+8C718B818B838C948C448D6F8E4E8E4D8E539442944D9454944E8F409443907E
+9138973C974097C09199919F91A1919D995A9A5193839ADD936493569C380000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+60
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000937C9C459C3A93769C359350935193609EF1938F9F93529A937993578641
+5DD7934F65289377937B936170537059936772219359766F793779B57C627C5E
+7CF596AE96B0863D9720882D89898B8D8B878B908D1A8E99979E979D97D5945F
+97F1984194569461945B945A945C9465992B9741992A9933986E986C986D9931
+99AA9A5C9A589ADE9A029C4F9C5199F79C5399F899F699FB9DFC9F3999FC513E
+9ABE56D29AFD5B4F6B149B487A727A739B9E9B9B9BA68B919BA59BA491BF0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+61
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009BA2946C9BAF9D3396E697459D3697C897E4995D9D389B219D459B2C9B57
+9D3E9D379C5D9C619C659E089E8A9E899E8D9EB09EC89F459EFB9EFF620566EF
+6B1B6B1D722572247C6D512E8642864956978978898A8B9759708C9B8D1C5C6A
+8EA25E6D5E6E61D861DF61ED61EE61F161EA9C6C61EB9C6F61E99E0E65049F08
+9F1D9FA3650364FC5F606B1C66DA66DB66D87CF36AB98B9B8EA791C46ABA947A
+6AB76AC79A619A639AD79C766C0B9FA5700C7067700172AB864A897D8B9D0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+62
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00008C538F65947B6FFC98CD98DD72019B309E16720371FD737674B874C096E7
+9E189EA274B69F7C74C27E9E9484765C9E1C76597C7197CA7657765A76A69EA3
+76EC9C7B9F97790C7913975079097910791257275C1379AC7A5F7C1C7C297C19
+7C205FC87C2D7C1D7C267C287C2267657C307E5C52BD7E565B667E5865F96788
+6CE66CCB7E574FBD5F8D7FB36018604880756B2970A681D07706825E85B485C6
+5A105CFC5CFE85B385B585BD85C785C485BF70C985CE85C885C585B185B60000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+63
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000085D28624957985B796BA866987E787E687E287DB87EB87EA7B29812887F3
+8A2E87D487DC87D39AD987D8582B584587D963FA87F487E887DD6E86894B894F
+894C89468950586789495BDD656E8B238B338B308C878B4750D250DF8B3E8B31
+8B258B3769BA8B366B9D8B2480598B3D8B3A8C428C758C998C988C978CFE8D04
+8D028D008E5C6F8A8E608E577BC37BC28E658E678E5B8E5A90F68E5D98238E54
+8F468F478F488F4B71CD7499913B913E91A891A591A7984291AA93B5938C0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+64
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000093927F84939B939D938993A7938E8D0E939E9861939593888B73939F9C27
+938D945877D69B2D93A493A893B493A395D295D395D196B396D796DA5DC296DF
+96D896DD97239722972597AC97AE97A84F664F684FE7503F97A550A6510F523E
+53245365539B517F54CB55735571556B55F456225620569256BA569156B05759
+578A580F581258135847589B5900594D5AD15AD35B675C575C775CD55D755D8E
+5DA55DB65DBF5E655ECD5EED5F945F9A5FBA6125615062A36360636463B60000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+65
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000640364B6651A7A255C2166E2670267A467AC68106806685E685A692C6929
+6A2D6A776A7A6ACA6AE66AF56B0D6B0E6BDC6BDD6BF66C1E6C636DA56E0F6E8A
+6E846E8B6E7C6F4C6F486F496F9D6F996FF8702E702D705C79CC70BF70EA70E5
+71117112713F7139713B713D71777175717671717196719371B471DD71DE720E
+591172187347734873EF7412743B74A4748D74B47673767776BC7819781B783D
+78537854785878B778D878EE7922794D7986799979A379BC7AA77B377B590000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+66
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00007BD07C2F7C327C427C4E7C687CA97CED7DD07E077DD37E647F40791E8041
+806380BB6711672582488310836283128421841E84E284DE84E1857385D485F5
+863786458672874A87A987A587F5883488508887895489848B038C528CD88D0C
+8D188DB08EBC8ED58FAA909C85E8915C922B9221927392F492F5933F93429386
+93BE93BC93BD93F193F293EF94229423942494679466959795CE95E7973B974D
+98E499429B1D9B9889629D4964495E715E8561D3990E8002781E898889B70000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+67
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005528557255BA55F055EE56B856B956C4805392B08B558B518B428B528B57
+8C438C778C768C9A8D068D078D098DAC8DAA8DAD8DAB8E6D8E788E738E6A8E6F
+8E7B8EC28F528F518F4F8F508F538FB49140913F91B091AD93DE93C793CF93C2
+93DA93D093F993EC93CC93D993A993E693CA93D493EE93E393D593C493CE93C0
+93D293A593E7957D95DA95DB96E19729972B972C9728972697B397B797B697DD
+97DE97DF985C9859985D985798BF98BD98BB98BE99489947994399A699A70000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+68
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009A1A9A159A259A1D9A249A1B9A229A209A279A239A1E9A1C9A149AC29B0B
+9B0A9B0E9B0C9B379BEA9BEB9BE09BDE9BE49BE69BE29BF09BD49BD79BEC9BDC
+9BD99BE59BD59BE19BDA9D779D819D8A9D849D889D719D809D789D869D8B9D8C
+9D7D9D6B9D749D759D709D699D859D739D7B9D829D6F9D799D7F9D879D689E94
+9E919EC09EFC9F2D9F409F419F4D9F569F579F58533756B256B556B358E35B45
+5DC65DC75EEE5EEF5FC05FC161F9651765166515651365DF66E866E366E40000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+69
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006AF36AF06AEA6AE86AF96AF16AEE6AEF703C7035702F7037703470317042
+7038703F703A7039702A7040703B703370417213721472A8737D737C74BA76AB
+76AA76BE76ED77CC77CE77CF77CD77F279257923792779287924792979B27A6E
+7A6C7A6D7AF77C497C487C4A7C477C457CEE7E7B7E7E7E817E807FBA7FFF8079
+81DB81D982688269862285FF860185FE861B860085F6860486098605860C85FD
+8819881088118817881388168963896689B989F78B608B6A8B5D8B688B630000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+6A
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00008B658B678B6D8DAE8E868E888E848F598F568F578F558F588F5A908D9143
+914191B791B591B291B3940B941393FB9420940F941493FE9415941094289419
+940D93F5940093F79407940E9416941293FA940993F8943C940A93FF93FC940C
+93F69411940695DE95E095DF972E972F97B997BB97FD97FE986098629863985F
+98C198C29950994E9959994C994B99539A329A349A319A2C9A2A9A369A299A2E
+9A389A2D9AC79ACA9AC69B109B129B119C0B9C089BF79C059C129BF89C400000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+6B
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009C079C0E9C069C179C149C099D9F9D999DA49D9D9D929D989D909D9B9DA0
+9D949D9C9DAA9D979DA19D9A9DA29DA89D9E9DA39DBF9DA99D969DA69DA79E99
+9E9B9E9A9EE59EE49EE79EE69F309F2E9F5B9F609F5E9F5D9F599F91513A5139
+5298529756C356BD56BE5B485B475DCB5DCF5EF161FD651B6B026AFC6B036AF8
+6B0070437044704A7048704970457046721D721A7219737E7517766A77D0792D
+7931792F7C547C537CF27E8A7E877E887E8B7E867E8D7F4D7FBB803081DD0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+6C
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00008618862A8626861F8623861C86198627862E862186208629861E86258829
+881D881B88208824881C882B884A896D8969896E896B89FA8B798B788B458B7A
+8B7B8D108D148DAF8E8E8E8C8F5E8F5B8F5D91469144914591B9943F943B9436
+9429943D94309439942A9437942C9440943195E595E495E39735973A97BF97E1
+986498C998C698C0995899569A399A3D9A469A449A429A419A3A9A3F9ACD9B15
+9B179B189B169B3A9B529C2B9C1D9C1C9C2C9C239C289C299C249C219DB70000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+6D
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009DB69DBC9DC19DC79DCA9DCF9DBE9DC59DC39DBB9DB59DCE9DB99DBA9DAC
+9DC89DB19DAD9DCC9DB39DCD9DB29E7A9E9C9EEB9EEE9EED9F1B9F189F1A9F31
+9F4E9F659F649F924EB956C656C556CB59715B4B5B4C5DD55DD15EF265216520
+652665226B0B6B086B096C0D7055705670577052721E721F72A9737F74D874D5
+74D974D7766D76AD793579B47A707A717C577C5C7C597C5B7C5A7CF47CF17E91
+7F4F7F8781DE826B863486358633862C86328636882C88288826882A88250000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+6E
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000897189BF89BE89FB8B7E8B848B828B868B858B7F8D158E958E948E9A8E92
+8E908E968E978F608F629147944C9450944A944B944F94479445944894499446
+973F97E3986A986998CB9954995B9A4E9A539A549A4C9A4F9A489A4A9A499A52
+9A509AD09B199B2B9B3B9B569B559C469C489C3F9C449C399C339C419C3C9C37
+9C349C329C3D9C369DDB9DD29DDE9DDA9DCB9DD09DDC9DD19DDF9DE99DD99DD8
+9DD69DF59DD59DDD9EB69EF09F359F339F329F429F6B9F959FA2513D52990000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+6F
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000058E858E759725B4D5DD8882F5F4F62016203620465296525659666EB6B11
+6B126B0F6BCA705B705A7222738273817383767077D47C677C667E95826C863A
+86408639863C8631863B863E88308832882E883389768974897389FE8B8C8B8E
+8B8B8B888C458D198E988F648F6391BC94629455945D9457945E97C497C59800
+9A569A599B1E9B1F9B209C529C589C509C4A9C4D9C4B9C559C599C4C9C4E9DFB
+9DF79DEF9DE39DEB9DF89DE49DF69DE19DEE9DE69DF29DF09DE29DEC9DF40000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+70
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009DF39DE89DED9EC29ED09EF29EF39F069F1C9F389F379F369F439F4F9F71
+9F709F6E9F6F56D356CD5B4E5C6D652D66ED66EE6B13705F7061705D70607223
+74DB74E577D5793879B779B67C6A7E977F89826D8643883888378835884B8B94
+8B958E9E8E9F8EA08E9D91BE91BD91C2946B9468946996E597469743974797C7
+97E59A5E9AD59B599C639C679C669C629C5E9C609E029DFE9E079E039E069E05
+9E009E019E099DFF9DFD9E049EA09F1E9F469F749F759F7656D4652E65B80000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+71
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006B186B196B176B1A7062722672AA77D877D979397C697C6B7CF67E9A7E98
+7E9B7E9981E081E18646864786488979897A897C897B89FF8B988B998EA58EA4
+8EA3946E946D946F9471947397499872995F9C689C6E9C6D9E0B9E0D9E109E0F
+9E129E119EA19EF59F099F479F789F7B9F7A9F79571E70667C6F883C8DB28EA6
+91C394749478947694759A609B2E9C749C739C719C759E149E139EF69F0A9FA4
+706870657CF7866A883E883D883F8B9E8C9C8EA98EC9974B9873987498CC0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+72
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000996199AB9A649A669A679B249E159E179F4862076B1E7227864C8EA89482
+948094819A699A689E19864B8B9F94839C799EB776759A6B9C7A9E1D7069706A
+72299EA49F7E9F499F988AF68AFC8C6B8C6D8C938CF48E448E318E348E428E39
+8E358F3B8F2F8F388F338FA88FA69075907490789072907C907A913491929320
+933692F89333932F932292FC932B9304931A9310932693219315932E931995BB
+96A796A896AA96D5970E97119716970D9713970F975B975C9766979898300000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+73
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009838983B9837982D9839982499109928991E991B9921991A99ED99E299F1
+9AB89ABC9AFB9AED9B289B919D159D239D269D289D129D1B9ED89ED49F8D9F9C
+512A511F5121513252F5568E5680569056855687568F58D558D358D158CE5B30
+5B2A5B245B7A5C375C685DBC5DBA5DBD5DB85E6B5F4C5FBD61C961C261C761E6
+61CB6232623464CE64CA64D864E064F064E664EC64F164E264ED6582658366D9
+66D66A806A946A846AA26A9C6ADB6AA36A7E6A976A906AA06B5C6BAE6BDA0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+74
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006C086FD86FF16FDF6FE06FDB6FE46FEB6FEF6F806FEC6FE16FE96FD56FEE
+6FF071E771DF71EE71E671E571ED71EC71F471E0723572467370737274A974B0
+74A674A876467642764C76EA77B377AA77B077AC77A777AD77EF78F778FA78F4
+78EF790179A779AA7A577ABF7C077C0D7BFE7BF77C0C7BE07CE07CDC7CDE7CE2
+7CDF7CD97CDD7E2E7E3E7E467E377E327E437E2B7E3D7E317E457E417E347E39
+7E487E357E3F7E2F7F447FF37FFC807180728070806F807381C681C381BA0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+75
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000081C281C081BF81BD81C981BE81E88209827185AA8584857E859C85918594
+85AF859B858785A8858A85A6866787C087D187B387D287C687AB87BB87BA87C8
+87CB893B893689448938893D89AC8B0E8B178B198B1B8B0A8B208B1D8B048B10
+8C418C3F8C738CFA8CFD8CFC8CF88CFB8DA88E498E4B8E488E4A8F448F3E8F42
+8F458F3F907F907D9084908190829080913991A3919E919C934D938293289375
+934A9365934B9318937E936C935B9370935A935495CA95CB95CC95C895C60000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+76
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000096B196B896D6971C971E97A097D3984698B699359A0199FF9BAE9BAB9BAA
+9BAD9D3B9D3F9E8B9ECF9EDE9EDC9EDD9EDB9F3E9F4B53E2569556AE58D958D8
+5B385F5E61E3623364F464F264FE650664FA64FB64F765B766DC67266AB36AAC
+6AC36ABB6AB86AC26AAE6AAF6B5F6B786BAF7009700B6FFE70066FFA7011700F
+71FB71FC71FE71F87377737574A774BF751576567658765277BD77BF77BB77BC
+790E79AE7A617A627A607AC47AC57C2B7C277C2A7C1E7C237C217CE77E540000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+77
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00007E557E5E7E5A7E617E527E597F487FF97FFB8077807681CD81CF820A85CF
+85A985CD85D085C985B085BA85B987EF87EC87F287E0898689B289F48B288B39
+8B2C8B2B8C508D058E598E638E668E648E5F8E558EC08F498F4D908790839088
+91AB91AC91D09394938A939693A293B393AE93AC93B09398939A939795D495D6
+95D095D596E296DC96D996DB96DE972497A397A697AD97F9984D984F984C984E
+985398BA993E993F993D992E99A59A0E9AC19B039B069B4F9B4E9B4D9BCA0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+78
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009BC99BFD9BC89BC09D519D5D9D609EE09F159F2C513356A556A858DE58DF
+58E25BF59F905EEC61F261F761F661F56500650F66E066DD6AE56ADD6ADA6AD3
+701B701F7028701A701D701570187206720D725872A27378737A74BD74CA74E3
+75877586765F766177C7791979B17A6B7A697C3E7C3F7C387C3D7C377C407E6B
+7E6D7E797E697E6A7E737F857FB67FB97FB881D885E985DD85EA85D585E485E5
+85F787FB8805880D87F987FE8960895F8956895E8B418B5C8B588B498B5A0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+79
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00008B4E8B4F8B468B598D088D0A8E7C8E728E878E768E6C8E7A8E748F548F4E
+8FAD908A908B91B191AE93E193D193DF93C393C893DC93DD93D693E293CD93D8
+93E493D793E895DC96B496E3972A9727976197DC97FB985E9858985B98BC9945
+99499A169A199B0D9BE89BE79BD69BDB9D899D619D729D6A9D6C9E929E979E93
+9EB452F856B756B656B456BC58E45B405B435B7D5BF65DC961F861FA65186514
+651966E667276AEC703E703070327210737B74CF766276657926792A792C0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+7A
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000792B7AC77AF67C4C7C437C4D7CEF7CF08FAE7E7D7E7C7E827F4C800081DA
+826685FB85F9861185FA8606860B8607860A88148815896489BA89F88B708B6C
+8B668B6F8B5F8B6B8D0F8D0D8E898E818E858E8291B491CB9418940393FD95E1
+973098C49952995199A89A2B9A309A379A359C139C0D9E799EB59EE89F2F9F5F
+9F639F615137513856C156C056C259145C6C5DCD61FC61FE651D651C659566E9
+6AFB6B046AFA6BB2704C721B72A774D674D4766977D37C507E8F7E8C7FBC0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+7B
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00008617862D861A882388228821881F896A896C89BD8B748B778B7D8D138E8A
+8E8D8E8B8F5F8FAF91BA942E94339435943A94389432942B95E2973897399732
+97FF9867986599579A459A439A409A3E9ACF9B549B519C2D9C259DAF9DB49DC2
+9DB89E9D9EEF9F199F5C9F669F67513C513B56C856CA56C95B7F5DD45DD25F4E
+61FF65246B0A6B6170517058738074E4758A766E766C79B37C607C5F807E807D
+81DF8972896F89FC8B808D168D178E918E938F619148944494519452973D0000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+7C
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000973E97C397C1986B99559A559A4D9AD29B1A9C499C319C3E9C3B9DD39DD7
+9F349F6C9F6A9F9456CC5DD662006523652B652A66EC6B1074DA7ACA7C647C63
+7C657E937E967E9481E28638863F88318B8A9090908F9463946094649768986F
+995C9A5A9A5B9A579AD39AD49AD19C549C579C569DE59E9F9EF456D158E9652C
+705E7671767277D77F507F888836883988628B938B928B9682778D1B91C0946A
+97429748974497C698709A5F9B229B589C5F9DF99DFA9E7C9E7D9F079F770000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+7D
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009F725EF36B1670637C6C7C6E883B89C08EA191C1947294709871995E9AD6
+9B239ECC706477DA8B9A947797C99A629A657E9C8B9C8EAA91C5947D947E947C
+9C779C789EF78C54947F9E1A72289A6A9B319E1B9E1E7C720000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000

janus/lib/tcl8.6/encoding/cp1250.enc

@@ -0,0 +1,20 @@
+# Encoding file: cp1250, single-byte
+S
+003F 0 1
+00
+0000000100020003000400050006000700080009000A000B000C000D000E000F
+0010001100120013001400150016001700180019001A001B001C001D001E001F
+0020002100220023002400250026002700280029002A002B002C002D002E002F
+0030003100320033003400350036003700380039003A003B003C003D003E003F
+0040004100420043004400450046004700480049004A004B004C004D004E004F
+0050005100520053005400550056005700580059005A005B005C005D005E005F
+0060006100620063006400650066006700680069006A006B006C006D006E006F
+0070007100720073007400750076007700780079007A007B007C007D007E007F
+20AC0081201A0083201E2026202020210088203001602039015A0164017D0179
+009020182019201C201D202220132014009821220161203A015B0165017E017A
+00A002C702D8014100A4010400A600A700A800A9015E00AB00AC00AD00AE017B
+00B000B102DB014200B400B500B600B700B80105015F00BB013D02DD013E017C
+015400C100C2010200C40139010600C7010C00C9011800CB011A00CD00CE010E
+01100143014700D300D4015000D600D70158016E00DA017000DC00DD016200DF
+015500E100E2010300E4013A010700E7010D00E9011900EB011B00ED00EE010F
+01110144014800F300F4015100F600F70159016F00FA017100FC00FD016302D9

janus/lib/tcl8.6/encoding/cp1251.enc

@@ -0,0 +1,20 @@
+# Encoding file: cp1251, single-byte
+S
+003F 0 1
+00
+0000000100020003000400050006000700080009000A000B000C000D000E000F
+0010001100120013001400150016001700180019001A001B001C001D001E001F
+0020002100220023002400250026002700280029002A002B002C002D002E002F
+0030003100320033003400350036003700380039003A003B003C003D003E003F
+0040004100420043004400450046004700480049004A004B004C004D004E004F
+0050005100520053005400550056005700580059005A005B005C005D005E005F
+0060006100620063006400650066006700680069006A006B006C006D006E006F
+0070007100720073007400750076007700780079007A007B007C007D007E007F
+04020403201A0453201E20262020202120AC203004092039040A040C040B040F
+045220182019201C201D202220132014009821220459203A045A045C045B045F
+00A0040E045E040800A4049000A600A7040100A9040400AB00AC00AD00AE0407
+00B000B104060456049100B500B600B704512116045400BB0458040504550457
+0410041104120413041404150416041704180419041A041B041C041D041E041F
+0420042104220423042404250426042704280429042A042B042C042D042E042F
+0430043104320433043404350436043704380439043A043B043C043D043E043F
+0440044104420443044404450446044704480449044A044B044C044D044E044F

janus/lib/tcl8.6/encoding/cp1252.enc

@@ -0,0 +1,20 @@
+# Encoding file: cp1252, single-byte
+S
+003F 0 1
+00
+0000000100020003000400050006000700080009000A000B000C000D000E000F
+0010001100120013001400150016001700180019001A001B001C001D001E001F
+0020002100220023002400250026002700280029002A002B002C002D002E002F
+0030003100320033003400350036003700380039003A003B003C003D003E003F
+0040004100420043004400450046004700480049004A004B004C004D004E004F
+0050005100520053005400550056005700580059005A005B005C005D005E005F
+0060006100620063006400650066006700680069006A006B006C006D006E006F
+0070007100720073007400750076007700780079007A007B007C007D007E007F
+20AC0081201A0192201E20262020202102C62030016020390152008D017D008F
+009020182019201C201D20222013201402DC21220161203A0153009D017E0178
+00A000A100A200A300A400A500A600A700A800A900AA00AB00AC00AD00AE00AF
+00B000B100B200B300B400B500B600B700B800B900BA00BB00BC00BD00BE00BF
+00C000C100C200C300C400C500C600C700C800C900CA00CB00CC00CD00CE00CF
+00D000D100D200D300D400D500D600D700D800D900DA00DB00DC00DD00DE00DF
+00E000E100E200E300E400E500E600E700E800E900EA00EB00EC00ED00EE00EF
+00F000F100F200F300F400F500F600F700F800F900FA00FB00FC00FD00FE00FF

janus/lib/tcl8.6/encoding/cp1254.enc

@@ -0,0 +1,20 @@
+# Encoding file: cp1254, single-byte
+S
+003F 0 1
+00
+0000000100020003000400050006000700080009000A000B000C000D000E000F
+0010001100120013001400150016001700180019001A001B001C001D001E001F
+0020002100220023002400250026002700280029002A002B002C002D002E002F
+0030003100320033003400350036003700380039003A003B003C003D003E003F
+0040004100420043004400450046004700480049004A004B004C004D004E004F
+0050005100520053005400550056005700580059005A005B005C005D005E005F
+0060006100620063006400650066006700680069006A006B006C006D006E006F
+0070007100720073007400750076007700780079007A007B007C007D007E007F
+20AC0081201A0192201E20262020202102C62030016020390152008D008E008F
+009020182019201C201D20222013201402DC21220161203A0153009D009E0178
+00A000A100A200A300A400A500A600A700A800A900AA00AB00AC00AD00AE00AF
+00B000B100B200B300B400B500B600B700B800B900BA00BB00BC00BD00BE00BF
+00C000C100C200C300C400C500C600C700C800C900CA00CB00CC00CD00CE00CF
+011E00D100D200D300D400D500D600D700D800D900DA00DB00DC0130015E00DF
+00E000E100E200E300E400E500E600E700E800E900EA00EB00EC00ED00EE00EF
+011F00F100F200F300F400F500F600F700F800F900FA00FB00FC0131015F00FF

janus/lib/tcl8.6/encoding/cp1255.enc

@@ -0,0 +1,20 @@
+# Encoding file: cp1255, single-byte
+S
+003F 0 1
+00
+0000000100020003000400050006000700080009000A000B000C000D000E000F
+0010001100120013001400150016001700180019001A001B001C001D001E001F
+0020002100220023002400250026002700280029002A002B002C002D002E002F
+0030003100320033003400350036003700380039003A003B003C003D003E003F
+0040004100420043004400450046004700480049004A004B004C004D004E004F
+0050005100520053005400550056005700580059005A005B005C005D005E005F
+0060006100620063006400650066006700680069006A006B006C006D006E006F
+0070007100720073007400750076007700780079007A007B007C007D007E007F
+20AC0081201A0192201E20262020202102C62030008A2039008C008D008E008F
+009020182019201C201D20222013201402DC2122009A203A009C009D009E009F
+00A000A100A200A320AA00A500A600A700A800A900D700AB00AC00AD00AE00AF
+00B000B100B200B300B400B500B600B700B800B900F700BB00BC00BD00BE00BF
+05B005B105B205B305B405B505B605B705B805B9000005BB05BC05BD05BE05BF
+05C005C105C205C305F005F105F205F305F40000000000000000000000000000
+05D005D105D205D305D405D505D605D705D805D905DA05DB05DC05DD05DE05DF
+05E005E105E205E305E405E505E605E705E805E905EA00000000200E200F0000

janus/lib/tcl8.6/encoding/cp1257.enc

@@ -0,0 +1,20 @@
+# Encoding file: cp1257, single-byte
+S
+003F 0 1
+00
+0000000100020003000400050006000700080009000A000B000C000D000E000F
+0010001100120013001400150016001700180019001A001B001C001D001E001F
+0020002100220023002400250026002700280029002A002B002C002D002E002F
+0030003100320033003400350036003700380039003A003B003C003D003E003F
+0040004100420043004400450046004700480049004A004B004C004D004E004F
+0050005100520053005400550056005700580059005A005B005C005D005E005F
+0060006100620063006400650066006700680069006A006B006C006D006E006F
+0070007100720073007400750076007700780079007A007B007C007D007E007F
+20AC0081201A0083201E20262020202100882030008A2039008C00A802C700B8
+009020182019201C201D20222013201400982122009A203A009C00AF02DB009F
+00A0000000A200A300A4000000A600A700D800A9015600AB00AC00AD00AE00C6
+00B000B100B200B300B400B500B600B700F800B9015700BB00BC00BD00BE00E6
+0104012E0100010600C400C501180112010C00C90179011601220136012A013B
+01600143014500D3014C00D500D600D701720141015A016A00DC017B017D00DF
+0105012F0101010700E400E501190113010D00E9017A011701230137012B013C
+01610144014600F3014D00F500F600F701730142015B016B00FC017C017E02D9

janus/lib/tcl8.6/encoding/cp737.enc

@@ -0,0 +1,20 @@
+# Encoding file: cp737, single-byte
+S
+003F 0 1
+00
+0000000100020003000400050006000700080009000A000B000C000D000E000F
+0010001100120013001400150016001700180019001A001B001C001D001E001F
+0020002100220023002400250026002700280029002A002B002C002D002E002F
+0030003100320033003400350036003700380039003A003B003C003D003E003F
+0040004100420043004400450046004700480049004A004B004C004D004E004F
+0050005100520053005400550056005700580059005A005B005C005D005E005F
+0060006100620063006400650066006700680069006A006B006C006D006E006F
+0070007100720073007400750076007700780079007A007B007C007D007E007F
+039103920393039403950396039703980399039A039B039C039D039E039F03A0
+03A103A303A403A503A603A703A803A903B103B203B303B403B503B603B703B8
+03B903BA03BB03BC03BD03BE03BF03C003C103C303C203C403C503C603C703C8
+259125922593250225242561256225562555256325512557255D255C255B2510
+25142534252C251C2500253C255E255F255A25542569256625602550256C2567
+2568256425652559255825522553256B256A2518250C25882584258C25902580
+03C903AC03AD03AE03CA03AF03CC03CD03CB03CE038603880389038A038C038E
+038F00B12265226403AA03AB00F7224800B0221900B7221A207F00B225A000A0

janus/lib/tcl8.6/encoding/cp775.enc

@@ -0,0 +1,20 @@
+# Encoding file: cp775, single-byte
+S
+003F 0 1
+00
+0000000100020003000400050006000700080009000A000B000C000D000E000F
+0010001100120013001400150016001700180019001A001B001C001D001E001F
+0020002100220023002400250026002700280029002A002B002C002D002E002F
+0030003100320033003400350036003700380039003A003B003C003D003E003F
+0040004100420043004400450046004700480049004A004B004C004D004E004F
+0050005100520053005400550056005700580059005A005B005C005D005E005F
+0060006100620063006400650066006700680069006A006B006C006D006E006F
+0070007100720073007400750076007700780079007A007B007C007D007E007F
+010600FC00E9010100E4012300E501070142011301560157012B017900C400C5
+00C900E600C6014D00F6012200A2015A015B00D600DC00F800A300D800D700A4
+0100012A00F3017B017C017A201D00A600A900AE00AC00BD00BC014100AB00BB
+259125922593250225240104010C01180116256325512557255D012E01602510
+25142534252C251C2500253C0172016A255A25542569256625602550256C017D
+0105010D01190117012F01610173016B017E2518250C25882584258C25902580
+00D300DF014C014300F500D500B5014401360137013B013C0146011201452019
+00AD00B1201C00BE00B600A700F7201E00B0221900B700B900B300B225A000A0

janus/lib/tcl8.6/encoding/cp861.enc

@@ -0,0 +1,20 @@
+# Encoding file: cp861, single-byte
+S
+003F 0 1
+00
+0000000100020003000400050006000700080009000A000B000C000D000E000F
+0010001100120013001400150016001700180019001A001B001C001D001E001F
+0020002100220023002400250026002700280029002A002B002C002D002E002F
+0030003100320033003400350036003700380039003A003B003C003D003E003F
+0040004100420043004400450046004700480049004A004B004C004D004E004F
+0050005100520053005400550056005700580059005A005B005C005D005E005F
+0060006100620063006400650066006700680069006A006B006C006D006E006F
+0070007100720073007400750076007700780079007A007B007C007D007E007F
+00C700FC00E900E200E400E000E500E700EA00EB00E800D000F000DE00C400C5
+00C900E600C600F400F600FE00FB00DD00FD00D600DC00F800A300D820A70192
+00E100ED00F300FA00C100CD00D300DA00BF231000AC00BD00BC00A100AB00BB
+259125922593250225242561256225562555256325512557255D255C255B2510
+25142534252C251C2500253C255E255F255A25542569256625602550256C2567
+2568256425652559255825522553256B256A2518250C25882584258C25902580
+03B100DF039303C003A303C300B503C403A6039803A903B4221E03C603B52229
+226100B1226522642320232100F7224800B0221900B7221A207F00B225A000A0

janus/lib/tcl8.6/encoding/cp866.enc

@@ -0,0 +1,20 @@
+# Encoding file: cp866, single-byte
+S
+003F 0 1
+00
+0000000100020003000400050006000700080009000A000B000C000D000E000F
+0010001100120013001400150016001700180019001A001B001C001D001E001F
+0020002100220023002400250026002700280029002A002B002C002D002E002F
+0030003100320033003400350036003700380039003A003B003C003D003E003F
+0040004100420043004400450046004700480049004A004B004C004D004E004F
+0050005100520053005400550056005700580059005A005B005C005D005E005F
+0060006100620063006400650066006700680069006A006B006C006D006E006F
+0070007100720073007400750076007700780079007A007B007C007D007E007F
+0410041104120413041404150416041704180419041A041B041C041D041E041F
+0420042104220423042404250426042704280429042A042B042C042D042E042F
+0430043104320433043404350436043704380439043A043B043C043D043E043F
+259125922593250225242561256225562555256325512557255D255C255B2510
+25142534252C251C2500253C255E255F255A25542569256625602550256C2567
+2568256425652559255825522553256B256A2518250C25882584258C25902580
+0440044104420443044404450446044704480449044A044B044C044D044E044F
+040104510404045404070457040E045E00B0221900B7221A211600A425A000A0

janus/lib/tcl8.6/encoding/dingbats.enc

@@ -0,0 +1,20 @@
+# Encoding file: dingbats, single-byte
+S
+003F 1 1
+00
+0000000100020003000400050006000700080009000A000B000C000D000E000F
+0010001100120013001400150016001700180019001A001B001C001D001E001F
+00202701270227032704260E2706270727082709261B261E270C270D270E270F
+2710271127122713271427152716271727182719271A271B271C271D271E271F
+2720272127222723272427252726272726052729272A272B272C272D272E272F
+2730273127322733273427352736273727382739273A273B273C273D273E273F
+2740274127422743274427452746274727482749274A274B25CF274D25A0274F
+27502751275225B225BC25C6275625D727582759275A275B275C275D275E007F
+0080008100820083008400850086008700880089008A008B008C008D008E008F
+0090009100920093009400950096009700980099009A009B009C009D009E009F
+0000276127622763276427652766276726632666266526602460246124622463
+2464246524662467246824692776277727782779277A277B277C277D277E277F
+2780278127822783278427852786278727882789278A278B278C278D278E278F
+2790279127922793279421922194219527982799279A279B279C279D279E279F
+27A027A127A227A327A427A527A627A727A827A927AA27AB27AC27AD27AE27AF
+000027B127B227B327B427B527B627B727B827B927BA27BB27BC27BD27BE0000

janus/lib/tcl8.6/encoding/euc-cn.enc

@@ -0,0 +1,1397 @@
+# Encoding file: euc-cn, multi-byte
+M
+003F 0 82
+00
+0000000100020003000400050006000700080009000A000B000C000D000E000F
+0010001100120013001400150016001700180019001A001B001C001D001E001F
+0020002100220023002400250026002700280029002A002B002C002D002E002F
+0030003100320033003400350036003700380039003A003B003C003D003E003F
+0040004100420043004400450046004700480049004A004B004C004D004E004F
+0050005100520053005400550056005700580059005A005B005C005D005E005F
+0060006100620063006400650066006700680069006A006B006C006D006E006F
+0070007100720073007400750076007700780079007A007B007C007D007E007F
+0080008100820083008400850086008700880089008A008B008C008D008E008F
+0090009100920093009400950096009700980099009A009B009C009D009E009F
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+A1
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000030003001300230FB02C902C700A8300330052015FF5E2225202620182019
+201C201D3014301530083009300A300B300C300D300E300F3016301730103011
+00B100D700F72236222722282211220F222A222922082237221A22A522252220
+23122299222B222E2261224C2248223D221D2260226E226F22642265221E2235
+22342642264000B0203220332103FF0400A4FFE0FFE1203000A7211626062605
+25CB25CF25CE25C725C625A125A025B325B2203B219221902191219330130000
+A2
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000024882489248A248B248C248D248E248F2490249124922493249424952496
+249724982499249A249B247424752476247724782479247A247B247C247D247E
+247F248024812482248324842485248624872460246124622463246424652466
+2467246824690000000032203221322232233224322532263227322832290000
+00002160216121622163216421652166216721682169216A216B000000000000
+A3
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000FF01FF02FF03FFE5FF05FF06FF07FF08FF09FF0AFF0BFF0CFF0DFF0EFF0F
+FF10FF11FF12FF13FF14FF15FF16FF17FF18FF19FF1AFF1BFF1CFF1DFF1EFF1F
+FF20FF21FF22FF23FF24FF25FF26FF27FF28FF29FF2AFF2BFF2CFF2DFF2EFF2F
+FF30FF31FF32FF33FF34FF35FF36FF37FF38FF39FF3AFF3BFF3CFF3DFF3EFF3F
+FF40FF41FF42FF43FF44FF45FF46FF47FF48FF49FF4AFF4BFF4CFF4DFF4EFF4F
+FF50FF51FF52FF53FF54FF55FF56FF57FF58FF59FF5AFF5BFF5CFF5DFFE30000
+A4
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000304130423043304430453046304730483049304A304B304C304D304E304F
+3050305130523053305430553056305730583059305A305B305C305D305E305F
+3060306130623063306430653066306730683069306A306B306C306D306E306F
+3070307130723073307430753076307730783079307A307B307C307D307E307F
+3080308130823083308430853086308730883089308A308B308C308D308E308F
+3090309130923093000000000000000000000000000000000000000000000000
+A5
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000030A130A230A330A430A530A630A730A830A930AA30AB30AC30AD30AE30AF
+30B030B130B230B330B430B530B630B730B830B930BA30BB30BC30BD30BE30BF
+30C030C130C230C330C430C530C630C730C830C930CA30CB30CC30CD30CE30CF
+30D030D130D230D330D430D530D630D730D830D930DA30DB30DC30DD30DE30DF
+30E030E130E230E330E430E530E630E730E830E930EA30EB30EC30ED30EE30EF
+30F030F130F230F330F430F530F6000000000000000000000000000000000000
+A6
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000039103920393039403950396039703980399039A039B039C039D039E039F
+03A003A103A303A403A503A603A703A803A90000000000000000000000000000
+000003B103B203B303B403B503B603B703B803B903BA03BB03BC03BD03BE03BF
+03C003C103C303C403C503C603C703C803C90000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+A7
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000004100411041204130414041504010416041704180419041A041B041C041D
+041E041F0420042104220423042404250426042704280429042A042B042C042D
+042E042F00000000000000000000000000000000000000000000000000000000
+000004300431043204330434043504510436043704380439043A043B043C043D
+043E043F0440044104420443044404450446044704480449044A044B044C044D
+044E044F00000000000000000000000000000000000000000000000000000000
+A8
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000010100E101CE00E0011300E9011B00E8012B00ED01D000EC014D00F301D2
+00F2016B00FA01D400F901D601D801DA01DC00FC00EA00000000000000000000
+0000000000000000000031053106310731083109310A310B310C310D310E310F
+3110311131123113311431153116311731183119311A311B311C311D311E311F
+3120312131223123312431253126312731283129000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+A9
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00000000000000002500250125022503250425052506250725082509250A250B
+250C250D250E250F2510251125122513251425152516251725182519251A251B
+251C251D251E251F2520252125222523252425252526252725282529252A252B
+252C252D252E252F2530253125322533253425352536253725382539253A253B
+253C253D253E253F2540254125422543254425452546254725482549254A254B
+0000000000000000000000000000000000000000000000000000000000000000
+B0
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000554A963F57C3632854CE550954C07691764C853C77EE827E788D72319698
+978D6C285B894FFA630966975CB880FA684880AE660276CE51F9655671AC7FF1
+888450B2596561CA6FB382AD634C625253ED54277B06516B75A45DF462D48DCB
+9776628A8019575D97387F627238767D67CF767E64464F708D2562DC7A176591
+73ED642C6273822C9881677F7248626E62CC4F3474E3534A529E7ECA90A65E2E
+6886699C81807ED168D278C5868C9551508D8C2482DE80DE5305891252650000
+B1
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000858496F94FDD582199715B9D62B162A566B48C799C8D7206676F789160B2
+535153178F8880CC8D1D94A1500D72C8590760EB711988AB595482EF672C7B28
+5D297EF7752D6CF58E668FF8903C9F3B6BD491197B145F7C78A784D6853D6BD5
+6BD96BD65E015E8775F995ED655D5F0A5FC58F9F58C181C2907F965B97AD8FB9
+7F168D2C62414FBF53D8535E8FA88FA98FAB904D68075F6A819888689CD6618B
+522B762A5F6C658C6FD26EE85BBE6448517551B067C44E1979C9997C70B30000
+B2
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000075C55E7673BB83E064AD62E894B56CE2535A52C3640F94C27B944F2F5E1B
+82368116818A6E246CCA9A736355535C54FA886557E04E0D5E036B657C3F90E8
+601664E6731C88C16750624D8D22776C8E2991C75F6983DC8521991053C28695
+6B8B60ED60E8707F82CD82314ED36CA785CF64CD7CD969FD66F9834953957B56
+4FA7518C6D4B5C428E6D63D253C9832C833667E578B4643D5BDF5C945DEE8BE7
+62C667F48C7A640063BA8749998B8C177F2094F24EA7961098A4660C73160000
+B3
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000573A5C1D5E38957F507F80A05382655E7545553150218D856284949E671D
+56326F6E5DE2543570928F66626F64A463A35F7B6F8890F481E38FB05C186668
+5FF16C8996488D81886C649179F057CE6A59621054484E587A0B60E96F848BDA
+627F901E9A8B79E4540375F4630153196C608FDF5F1B9A70803B9F7F4F885C3A
+8D647FC565A570BD514551B2866B5D075BA062BD916C75748E0C7A2061017B79
+4EC77EF877854E1181ED521D51FA6A7153A88E87950496CF6EC19664695A0000
+B4
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000784050A877D7641089E6590463E35DDD7A7F693D4F20823955984E3275AE
+7A975E625E8A95EF521B5439708A6376952457826625693F918755076DF37EAF
+882262337EF075B5832878C196CC8F9E614874F78BCD6B64523A8D506B21806A
+847156F153064ECE4E1B51D17C97918B7C074FC38E7F7BE17A9C64675D1450AC
+810676017CB96DEC7FE067515B585BF878CB64AE641363AA632B9519642D8FBE
+7B5476296253592754466B7950A362345E266B864EE38D37888B5F85902E0000
+B5
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006020803D62C54E39535590F863B880C665E66C2E4F4660EE6DE18BDE5F39
+86CB5F536321515A83616863520063638E4850125C9B79775BFC52307A3B60BC
+905376D75FB75F9776848E6C706F767B7B4977AA51F3909358244F4E6EF48FEA
+654C7B1B72C46DA47FDF5AE162B55E95573084827B2C5E1D5F1F90127F1498A0
+63826EC7789870B95178975B57AB75354F4375385E9760E659606DC06BBF7889
+53FC96D551CB52016389540A94938C038DCC7239789F87768FED8C0D53E00000
+B6
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00004E0176EF53EE948998769F0E952D5B9A8BA24E224E1C51AC846361C252A8
+680B4F97606B51BB6D1E515C6296659796618C46901775D890FD77636BD2728A
+72EC8BFB583577798D4C675C9540809A5EA66E2159927AEF77ED953B6BB565AD
+7F0E58065151961F5BF958A954288E726566987F56E4949D76FE9041638754C6
+591A593A579B8EB267358DFA8235524160F0581586FE5CE89E454FC4989D8BB9
+5A2560765384627C904F9102997F6069800C513F80335C1499756D314E8C0000
+B7
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00008D3053D17F5A7B4F4F104E4F96006CD573D085E95E06756A7FFB6A0A77FE
+94927E4151E170E653CD8FD483038D2972AF996D6CDB574A82B365B980AA623F
+963259A84EFF8BBF7EBA653E83F2975E556198DE80A5532A8BFD542080BA5E9F
+6CB88D3982AC915A54296C1B52067EB7575F711A6C7E7C89594B4EFD5FFF6124
+7CAA4E305C0167AB87025CF0950B98CE75AF70FD902251AF7F1D8BBD594951E4
+4F5B5426592B657780A45B75627662C28F905E456C1F7B264F0F4FD8670D0000
+B8
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006D6E6DAA798F88B15F17752B629A8F854FEF91DC65A7812F81515E9C8150
+8D74526F89868D4B590D50854ED8961C723681798D1F5BCC8BA3964459877F1A
+54905676560E8BE565396982949976D66E895E727518674667D17AFF809D8D76
+611F79C665628D635188521A94A27F38809B7EB25C976E2F67607BD9768B9AD8
+818F7F947CD5641E95507A3F544A54E56B4C640162089E3D80F3759952729769
+845B683C86E49601969494EC4E2A54047ED968398DDF801566F45E9A7FB90000
+B9
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000057C2803F68975DE5653B529F606D9F9A4F9B8EAC516C5BAB5F135DE96C5E
+62F18D21517194A952FE6C9F82DF72D757A267848D2D591F8F9C83C754957B8D
+4F306CBD5B6459D19F1353E486CA9AA88C3780A16545987E56FA96C7522E74DC
+52505BE1630289024E5662D0602A68FA51735B9851A089C27BA199867F5060EF
+704C8D2F51495E7F901B747089C4572D78455F529F9F95FA8F689B3C8BE17678
+684267DC8DEA8D35523D8F8A6EDA68CD950590ED56FD679C88F98FC754C80000
+BA
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009AB85B696D776C264EA55BB39A87916361A890AF97E9542B6DB55BD251FD
+558A7F557FF064BC634D65F161BE608D710A6C576C49592F676D822A58D5568E
+8C6A6BEB90DD597D801753F76D695475559D837783CF683879BE548C4F555408
+76D28C8996026CB36DB88D6B89109E648D3A563F9ED175D55F8872E0606854FC
+4EA86A2A886160528F7054C470D886799E3F6D2A5B8F5F187EA255894FAF7334
+543C539A5019540E547C4E4E5FFD745A58F6846B80E1877472D07CCA6E560000
+BB
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005F27864E552C62A44E926CAA623782B154D7534E733E6ED1753B52125316
+8BDD69D05F8A60006DEE574F6B2273AF68538FD87F13636260A3552475EA8C62
+71156DA35BA65E7B8352614C9EC478FA87577C27768751F060F6714C66435E4C
+604D8C0E707063258F895FBD606286D456DE6BC160946167534960E066668D3F
+79FD4F1A70E96C478BB38BF27ED88364660F5A5A9B426D516DF78C416D3B4F19
+706B83B7621660D1970D8D27797851FB573E57FA673A75787A3D79EF7B950000
+BC
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000808C99658FF96FC08BA59E2159EC7EE97F095409678168D88F917C4D96C6
+53CA602575BE6C7253735AC97EA7632451E0810A5DF184DF628051805B634F0E
+796D524260B86D4E5BC45BC28BA18BB065E25FCC964559937EE77EAA560967B7
+59394F735BB652A0835A988A8D3E753294BE50477A3C4EF767B69A7E5AC16B7C
+76D1575A5C167B3A95F4714E517C80A9827059787F04832768C067EC78B17877
+62E363617B804FED526A51CF835069DB92748DF58D3189C1952E7BAD4EF60000
+BD
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000506582305251996F6E106E856DA75EFA50F559DC5C066D466C5F7586848B
+686859568BB253209171964D854969127901712680F64EA490CA6D479A845A07
+56BC640594F077EB4FA5811A72E189D2997A7F347EDE527F655991758F7F8F83
+53EB7A9663ED63A5768679F888579636622A52AB8282685467706377776B7AED
+6D017ED389E359D0621285C982A5754C501F4ECB75A58BEB5C4A5DFE7B4B65A4
+91D14ECA6D25895F7D2795264EC58C288FDB9773664B79818FD170EC6D780000
+BE
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005C3D52B283465162830E775B66769CB84EAC60CA7CBE7CB37ECF4E958B66
+666F988897595883656C955C5F8475C997567ADF7ADE51C070AF7A9863EA7A76
+7EA0739697ED4E4570784E5D915253A9655165E781FC8205548E5C31759A97A0
+62D872D975BD5C459A7983CA5C40548077E94E3E6CAE805A62D2636E5DE85177
+8DDD8E1E952F4FF153E560E770AC526763509E435A1F5026773753777EE26485
+652B628963985014723589C951B38BC07EDD574783CC94A7519B541B5CFB0000
+BF
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00004FCA7AE36D5A90E19A8F55805496536154AF5F0063E9697751EF6168520A
+582A52D8574E780D770B5EB761777CE0625B62974EA27095800362F770E49760
+577782DB67EF68F578D5989779D158F354B353EF6E34514B523B5BA28BFE80AF
+554357A660735751542D7A7A60505B5463A762A053E362635BC767AF54ED7A9F
+82E691775E9388E4593857AE630E8DE880EF57577B774FA95FEB5BBD6B3E5321
+7B5072C2684677FF773665F751B54E8F76D45CBF7AA58475594E9B4150800000
+C0
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000998861276E8357646606634656F062EC62695ED39614578362C955878721
+814A8FA3556683B167658D5684DD5A6A680F62E67BEE961151706F9C8C3063FD
+89C861D27F0670C26EE57405699472FC5ECA90CE67176D6A635E52B372628001
+4F6C59E5916A70D96D9D52D24E5096F7956D857E78CA7D2F5121579264C2808B
+7C7B6CEA68F1695E51B7539868A872819ECE7BF172F879BB6F137406674E91CC
+9CA4793C83898354540F68174E3D538952B1783E5386522950884F8B4FD00000
+C1
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000075E27ACB7C926CA596B6529B748354E94FE9805483B28FDE95705EC9601C
+6D9F5E18655B813894FE604B70BC7EC37CAE51C968817CB1826F4E248F8691CF
+667E4EAE8C0564A9804A50DA759771CE5BE58FBD6F664E86648295635ED66599
+521788C270C852A3730E7433679778F797164E3490BB9CDE6DCB51DB8D41541D
+62CE73B283F196F69F8494C34F367F9A51CC707596755CAD988653E64EE46E9C
+740969B4786B998F7559521876246D4167F3516D9F99804B54997B3C7ABF0000
+C2
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009686578462E29647697C5A0464027BD36F0F964B82A6536298855E907089
+63B35364864F9C819E93788C97328DEF8D429E7F6F5E79845F559646622E9A74
+541594DD4FA365C55C655C617F1586516C2F5F8B73876EE47EFF5CE6631B5B6A
+6EE653754E7163A0756562A18F6E4F264ED16CA67EB68BBA841D87BA7F57903B
+95237BA99AA188F8843D6D1B9A867EDC59889EBB739B780186829A6C9A82561B
+541757CB4E709EA653568FC881097792999286EE6EE1851366FC61626F2B0000
+C3
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00008C298292832B76F26C135FD983BD732B8305951A6BDB77DB94C6536F8302
+51925E3D8C8C8D384E4873AB679A68859176970971646CA177095A9295416BCF
+7F8E66275BD059B95A9A95E895F74EEC840C84996AAC76DF9530731B68A65B5F
+772F919A97617CDC8FF78C1C5F257C7379D889C56CCC871C5BC65E4268C97720
+7EF55195514D52C95A297F05976282D763CF778485D079D26E3A5E9959998511
+706D6C1162BF76BF654F60AF95FD660E879F9E2394ED540D547D8C2C64780000
+C4
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000647986116A21819C78E864699B5462B9672B83AB58A89ED86CAB6F205BDE
+964C8C0B725F67D062C772614EA959C66BCD589366AE5E5552DF6155672876EE
+776672677A4662FF54EA545094A090A35A1C7EB36C164E435976801059485357
+753796BE56CA63208111607C95F96DD65462998151855AE980FD59AE9713502A
+6CE55C3C62DF4F60533F817B90066EBA852B62C85E7478BE64B5637B5FF55A18
+917F9E1F5C3F634F80425B7D556E954A954D6D8560A867E072DE51DD5B810000
+C5
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000062E76CDE725B626D94AE7EBD81136D53519C5F04597452AA601259736696
+8650759F632A61E67CEF8BFA54E66B279E256BB485D5545550766CA4556A8DB4
+722C5E156015743662CD6392724C5F986E436D3E65006F5876D878D076FC7554
+522453DB4E535E9E65C1802A80D6629B5486522870AE888D8DD16CE1547880DA
+57F988F48D54966A914D4F696C9B55B776C6783062A870F96F8E5F6D84EC68DA
+787C7BF781A8670B9E4F636778B0576F78129739627962AB528874356BD70000
+C6
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005564813E75B276AE533975DE50FB5C418B6C7BC7504F72479A9798D86F02
+74E27968648777A562FC98918D2B54C180584E52576A82F9840D5E7351ED74F6
+8BC45C4F57616CFC98875A4678349B448FEB7C955256625194FA4EC683868461
+83E984B257D467345703666E6D668C3166DD7011671F6B3A6816621A59BB4E03
+51C46F0667D26C8F517668CB59476B6775665D0E81109F5065D7794879419A91
+8D775C824E5E4F01542F5951780C56686C148FC45F036C7D6CE38BAB63900000
+C7
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000060706D3D72756266948E94C553438FC17B7E4EDF8C264E7E9ED494B194B3
+524D6F5C90636D458C3458115D4C6B206B4967AA545B81547F8C589985375F3A
+62A26A47953965726084686577A74E544FA85DE7979864AC7FD85CED4FCF7A8D
+520783044E14602F7A8394A64FB54EB279E6743452E482B964D279BD5BDD6C81
+97528F7B6C22503E537F6E0564CE66746C3060C598778BF75E86743C7A7779CB
+4E1890B174036C4256DA914B6CC58D8B533A86C666F28EAF5C489A716E200000
+C8
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000053D65A369F8B8DA353BB570898A76743919B6CC9516875CA62F372AC5238
+529D7F3A7094763853749E4A69B7786E96C088D97FA4713671C3518967D374E4
+58E4651856B78BA9997662707ED560F970ED58EC4EC14EBA5FCD97E74EFB8BA4
+5203598A7EAB62544ECD65E5620E833884C98363878D71946EB65BB97ED25197
+63C967D480898339881551125B7A59828FB14E736C5D516589258F6F962E854A
+745E951095F06DA682E55F3164926D128428816E9CC3585E8D5B4E0953C10000
+C9
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00004F1E6563685155D34E2764149A9A626B5AC2745F82726DA968EE50E7838E
+7802674052396C997EB150BB5565715E7B5B665273CA82EB67495C715220717D
+886B95EA965564C58D6181B355846C5562477F2E58924F2455468D4F664C4E0A
+5C1A88F368A2634E7A0D70E7828D52FA97F65C1154E890B57ECD59628D4A86C7
+820C820D8D6664445C0461516D89793E8BBE78377533547B4F388EAB6DF15A20
+7EC5795E6C885BA15A76751A80BE614E6E1758F0751F7525727253477EF30000
+CA
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000770176DB526980DC57235E08593172EE65BD6E7F8BD75C388671534177F3
+62FE65F64EC098DF86805B9E8BC653F277E24F7F5C4E9A7659CB5F0F793A58EB
+4E1667FF4E8B62ED8A93901D52BF662F55DC566C90024ED54F8D91CA99706C0F
+5E0260435BA489C68BD56536624B99965B885BFF6388552E53D77626517D852C
+67A268B36B8A62928F9353D482126DD1758F4E668D4E5B70719F85AF669166D9
+7F7287009ECD9F205C5E672F8FF06811675F620D7AD658855EB665706F310000
+CB
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000060555237800D6454887075295E05681362F4971C53CC723D8C016C347761
+7A0E542E77AC987A821C8BF47855671470C165AF64955636601D79C153F84E1D
+6B7B80865BFA55E356DB4F3A4F3C99725DF3677E80386002988290015B8B8BBC
+8BF5641C825864DE55FD82CF91654FD77D20901F7C9F50F358516EAF5BBF8BC9
+80839178849C7B97867D968B968F7EE59AD3788E5C817A57904296A7795F5B59
+635F7B0B84D168AD55067F2974107D2295016240584C4ED65B83597958540000
+CC
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000736D631E8E4B8E0F80CE82D462AC53F06CF0915E592A60016C70574D644A
+8D2A762B6EE9575B6A8075F06F6D8C2D8C0857666BEF889278B363A253F970AD
+6C645858642A580268E0819B55107CD650188EBA6DCC8D9F70EB638F6D9B6ED4
+7EE68404684390036DD896768BA85957727985E4817E75BC8A8A68AF52548E22
+951163D098988E44557C4F5366FF568F60D56D9552435C4959296DFB586B7530
+751C606C82148146631167618FE2773A8DF38D3494C15E165385542C70C30000
+CD
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006C405EF7505C4EAD5EAD633A8247901A6850916E77B3540C94DC5F647AE5
+687663457B527EDF75DB507762955934900F51F879C37A8156FE5F9290146D82
+5C60571F541051546E4D56E263A89893817F8715892A9000541E5C6F81C062D6
+625881319E3596409A6E9A7C692D59A562D3553E631654C786D96D3C5A0374E6
+889C6B6A59168C4C5F2F6E7E73A9987D4E3870F75B8C7897633D665A769660CB
+5B9B5A494E0781556C6A738B4EA167897F515F8065FA671B5FD859845A010000
+CE
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005DCD5FAE537197E68FDD684556F4552F60DF4E3A6F4D7EF482C7840E59D4
+4F1F4F2A5C3E7EAC672A851A5473754F80C355829B4F4F4D6E2D8C135C096170
+536B761F6E29868A658795FB7EB9543B7A337D0A95EE55E17FC174EE631D8717
+6DA17A9D621165A1536763E16C835DEB545C94A84E4C6C618BEC5C4B65E0829C
+68A7543E54346BCB6B664E9463425348821E4F0D4FAE575E620A96FE66647269
+52FF52A1609F8BEF661471996790897F785277FD6670563B54389521727A0000
+CF
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00007A00606F5E0C6089819D591560DC718470EF6EAA6C5072806A8488AD5E2D
+4E605AB3559C94E36D177CFB9699620F7EC6778E867E5323971E8F9666875CE1
+4FA072ED4E0B53A6590F54136380952851484ED99C9C7EA454B88D2488548237
+95F26D8E5F265ACC663E966973B0732E53BF817A99857FA15BAA967796507EBF
+76F853A2957699997BB189446E584E617FD479658BE660F354CD4EAB98795DF7
+6A6150CF54118C618427785D9704524A54EE56A395006D885BB56DC666530000
+D0
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005C0F5B5D6821809655787B11654869544E9B6B47874E978B534F631F643A
+90AA659C80C18C10519968B0537887F961C86CC46CFB8C225C5185AA82AF950C
+6B238F9B65B05FFB5FC34FE18845661F8165732960FA51745211578B5F6290A2
+884C91925E78674F602759D3514451F680F853086C7996C4718A4F114FEE7F9E
+673D55C5950879C088967EE3589F620C9700865A5618987B5F908BB884C49157
+53D965ED5E8F755C60647D6E5A7F7EEA7EED8F6955A75BA360AC65CB73840000
+D1
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009009766377297EDA9774859B5B667A7496EA884052CB718F5FAA65EC8BE2
+5BFB9A6F5DE16B896C5B8BAD8BAF900A8FC5538B62BC9E269E2D54404E2B82BD
+7259869C5D1688596DAF96C554D14E9A8BB6710954BD960970DF6DF976D04E25
+781487125CA95EF68A00989C960E708E6CBF594463A9773C884D6F1482735830
+71D5538C781A96C155015F6671305BB48C1A9A8C6B83592E9E2F79E76768626C
+4F6F75A17F8A6D0B96336C274EF075D2517B68376F3E90808170599674760000
+D2
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000064475C2790657A918C2359DA54AC8200836F898180006930564E80367237
+91CE51B64E5F987563964E1A53F666F3814B591C6DB24E0058F9533B63D694F1
+4F9D4F0A886398905937905779FB4EEA80F075916C825B9C59E85F5D69058681
+501A5DF24E5977E34EE5827A6291661390915C794EBF5F7981C69038808475AB
+4EA688D4610F6BC55FC64E4976CA6EA28BE38BAE8C0A8BD15F027FFC7FCC7ECE
+8335836B56E06BB797F3963459FB541F94F66DEB5BC5996E5C395F1596900000
+D3
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000537082F16A315A749E705E947F2883B984248425836787478FCE8D6276C8
+5F719896786C662054DF62E54F6381C375C85EB896CD8E0A86F9548F6CF36D8C
+6C38607F52C775285E7D4F1860A05FE75C24753190AE94C072B96CB96E389149
+670953CB53F34F5191C98BF153C85E7C8FC26DE44E8E76C26986865E611A8206
+4F594FDE903E9C7C61096E1D6E1496854E885A3196E84E0E5C7F79B95B878BED
+7FBD738957DF828B90C15401904755BB5CEA5FA161086B3272F180B28A890000
+D4
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006D745BD388D598848C6B9A6D9E336E0A51A4514357A38881539F63F48F95
+56ED54585706733F6E907F188FDC82D1613F6028966266F07EA68D8A8DC394A5
+5CB37CA4670860A6960580184E9190E75300966851418FD08574915D665597F5
+5B55531D78386742683D54C9707E5BB08F7D518D572854B1651266828D5E8D43
+810F846C906D7CDF51FF85FB67A365E96FA186A48E81566A90207682707671E5
+8D2362E952196CFD8D3C600E589E618E66FE8D60624E55B36E23672D8F670000
+D5
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000094E195F87728680569A8548B4E4D70B88BC86458658B5B857A84503A5BE8
+77BB6BE18A797C986CBE76CF65A98F975D2D5C5586386808536062187AD96E5B
+7EFD6A1F7AE05F706F335F20638C6DA867564E085E108D264ED780C07634969C
+62DB662D627E6CBC8D7571677F695146808753EC906E629854F286F08F998005
+951785178FD96D5973CD659F771F7504782781FB8D1E94884FA6679575B98BCA
+9707632F9547963584B8632377415F8172F04E896014657462EF6B63653F0000
+D6
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005E2775C790D18BC1829D679D652F5431871877E580A281026C414E4B7EC7
+804C76F4690D6B966267503C4F84574063076B628DBE53EA65E87EB85FD7631A
+63B781F381F47F6E5E1C5CD95236667A79E97A1A8D28709975D46EDE6CBB7A92
+4E2D76C55FE0949F88777EC879CD80BF91CD4EF24F17821F54685DDE6D328BCC
+7CA58F7480985E1A549276B15B99663C9AA473E0682A86DB6731732A8BF88BDB
+90107AF970DB716E62C477A956314E3B845767F152A986C08D2E94F87B510000
+D7
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00004F4F6CE8795D9A7B6293722A62FD4E1378168F6C64B08D5A7BC668695E84
+88C55986649E58EE72B6690E95258FFD8D5857607F008C0651C6634962D95353
+684C74228301914C55447740707C6D4A517954A88D4459FF6ECB6DC45B5C7D2B
+4ED47C7D6ED35B5081EA6E0D5B579B0368D58E2A5B977EFC603B7EB590B98D70
+594F63CD79DF8DB3535265CF79568BC5963B7EC494BB7E825634918967007F6A
+5C0A907566285DE64F5067DE505A4F5C57505EA7000000000000000000000000
+D8
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00004E8D4E0C51404E105EFF53454E154E984E1E9B325B6C56694E2879BA4E3F
+53154E47592D723B536E6C1056DF80E499976BD3777E9F174E364E9F9F104E5C
+4E694E9382885B5B556C560F4EC4538D539D53A353A553AE97658D5D531A53F5
+5326532E533E8D5C5366536352025208520E522D5233523F5240524C525E5261
+525C84AF527D528252815290529351827F544EBB4EC34EC94EC24EE84EE14EEB
+4EDE4F1B4EF34F224F644EF54F254F274F094F2B4F5E4F6765384F5A4F5D0000
+D9
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00004F5F4F574F324F3D4F764F744F914F894F834F8F4F7E4F7B4FAA4F7C4FAC
+4F944FE64FE84FEA4FC54FDA4FE34FDC4FD14FDF4FF85029504C4FF3502C500F
+502E502D4FFE501C500C50255028507E504350555048504E506C507B50A550A7
+50A950BA50D6510650ED50EC50E650EE5107510B4EDD6C3D4F584F654FCE9FA0
+6C467C74516E5DFD9EC999985181591452F9530D8A07531051EB591951554EA0
+51564EB3886E88A44EB5811488D279805B3488037FB851AB51B151BD51BC0000
+DA
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000051C7519651A251A58BA08BA68BA78BAA8BB48BB58BB78BC28BC38BCB8BCF
+8BCE8BD28BD38BD48BD68BD88BD98BDC8BDF8BE08BE48BE88BE98BEE8BF08BF3
+8BF68BF98BFC8BFF8C008C028C048C078C0C8C0F8C118C128C148C158C168C19
+8C1B8C188C1D8C1F8C208C218C258C278C2A8C2B8C2E8C2F8C328C338C358C36
+5369537A961D962296219631962A963D963C964296499654965F9667966C9672
+96749688968D969796B09097909B909D909990AC90A190B490B390B690BA0000
+DB
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000090B890B090CF90C590BE90D090C490C790D390E690E290DC90D790DB90EB
+90EF90FE91049122911E91239131912F913991439146520D594252A252AC52AD
+52BE54FF52D052D652F053DF71EE77CD5EF451F551FC9B2F53B65F01755A5DEF
+574C57A957A1587E58BC58C558D15729572C572A57335739572E572F575C573B
+574257695785576B5786577C577B5768576D5776577357AD57A4578C57B257CF
+57A757B4579357A057D557D857DA57D957D257B857F457EF57F857E457DD0000
+DC
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000580B580D57FD57ED5800581E5819584458205865586C58815889589A5880
+99A89F1961FF8279827D827F828F828A82A88284828E82918297829982AB82B8
+82BE82B082C882CA82E3829882B782AE82CB82CC82C182A982B482A182AA829F
+82C482CE82A482E1830982F782E4830F830782DC82F482D282D8830C82FB82D3
+8311831A83068314831582E082D5831C8351835B835C83088392833C83348331
+839B835E832F834F83478343835F834083178360832D833A8333836683650000
+DD
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00008368831B8369836C836A836D836E83B0837883B383B483A083AA8393839C
+8385837C83B683A9837D83B8837B8398839E83A883BA83BC83C1840183E583D8
+58078418840B83DD83FD83D6841C84388411840683D483DF840F840383F883F9
+83EA83C583C0842683F083E1845C8451845A8459847384878488847A84898478
+843C844684698476848C848E8431846D84C184CD84D084E684BD84D384CA84BF
+84BA84E084A184B984B4849784E584E3850C750D853884F08539851F853A0000
+DE
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00008556853B84FF84FC8559854885688564855E857A77A285438572857B85A4
+85A88587858F857985AE859C858585B985B785B085D385C185DC85FF86278605
+86298616863C5EFE5F08593C594180375955595A5958530F5C225C255C2C5C34
+624C626A629F62BB62CA62DA62D762EE632262F66339634B634363AD63F66371
+637A638E63B4636D63AC638A636963AE63BC63F263F863E063FF63C463DE63CE
+645263C663BE64456441640B641B6420640C64266421645E6484646D64960000
+DF
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000647A64B764B8649964BA64C064D064D764E464E265096525652E5F0B5FD2
+75195F11535F53F153FD53E953E853FB541254165406544B5452545354545456
+54435421545754595423543254825494547754715464549A549B548454765466
+549D54D054AD54C254B454D254A754A654D354D4547254A354D554BB54BF54CC
+54D954DA54DC54A954AA54A454DD54CF54DE551B54E7552054FD551454F35522
+5523550F55115527552A5567558F55B55549556D55415555553F5550553C0000
+E0
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005537555655755576557755335530555C558B55D2558355B155B955885581
+559F557E55D65591557B55DF55BD55BE5594559955EA55F755C9561F55D155EB
+55EC55D455E655DD55C455EF55E555F255F355CC55CD55E855F555E48F94561E
+5608560C56015624562355FE56005627562D565856395657562C564D56625659
+565C564C5654568656645671566B567B567C5685569356AF56D456D756DD56E1
+56F556EB56F956FF5704570A5709571C5E0F5E195E145E115E315E3B5E3C0000
+E1
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00005E375E445E545E5B5E5E5E615C8C5C7A5C8D5C905C965C885C985C995C91
+5C9A5C9C5CB55CA25CBD5CAC5CAB5CB15CA35CC15CB75CC45CD25CE45CCB5CE5
+5D025D035D275D265D2E5D245D1E5D065D1B5D585D3E5D345D3D5D6C5D5B5D6F
+5D5D5D6B5D4B5D4A5D695D745D825D995D9D8C735DB75DC55F735F775F825F87
+5F895F8C5F955F995F9C5FA85FAD5FB55FBC88625F6172AD72B072B472B772B8
+72C372C172CE72CD72D272E872EF72E972F272F472F7730172F3730372FA0000
+E2
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000072FB731773137321730A731E731D7315732273397325732C733873317350
+734D73577360736C736F737E821B592598E7592459029963996799689969996A
+996B996C99749977997D998099849987998A998D999099919993999499955E80
+5E915E8B5E965EA55EA05EB95EB55EBE5EB38D535ED25ED15EDB5EE85EEA81BA
+5FC45FC95FD65FCF60035FEE60045FE15FE45FFE600560065FEA5FED5FF86019
+60356026601B600F600D6029602B600A603F602160786079607B607A60420000
+E3
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000606A607D6096609A60AD609D60836092608C609B60EC60BB60B160DD60D8
+60C660DA60B4612061266115612360F46100610E612B614A617561AC619461A7
+61B761D461F55FDD96B395E995EB95F195F395F595F695FC95FE960396049606
+9608960A960B960C960D960F96129615961696179619961A4E2C723F62156C35
+6C546C5C6C4A6CA36C856C906C946C8C6C686C696C746C766C866CA96CD06CD4
+6CAD6CF76CF86CF16CD76CB26CE06CD66CFA6CEB6CEE6CB16CD36CEF6CFE0000
+E4
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006D396D276D0C6D436D486D076D046D196D0E6D2B6D4D6D2E6D356D1A6D4F
+6D526D546D336D916D6F6D9E6DA06D5E6D936D946D5C6D606D7C6D636E1A6DC7
+6DC56DDE6E0E6DBF6DE06E116DE66DDD6DD96E166DAB6E0C6DAE6E2B6E6E6E4E
+6E6B6EB26E5F6E866E536E546E326E256E446EDF6EB16E986EE06F2D6EE26EA5
+6EA76EBD6EBB6EB76ED76EB46ECF6E8F6EC26E9F6F626F466F476F246F156EF9
+6F2F6F366F4B6F746F2A6F096F296F896F8D6F8C6F786F726F7C6F7A6FD10000
+E5
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00006FC96FA76FB96FB66FC26FE16FEE6FDE6FE06FEF701A7023701B70397035
+704F705E5B805B845B955B935BA55BB8752F9A9E64345BE45BEE89305BF08E47
+8B078FB68FD38FD58FE58FEE8FE48FE98FE68FF38FE890059004900B90269011
+900D9016902190359036902D902F9044905190529050906890589062905B66B9
+9074907D908290889083908B5F505F575F565F585C3B54AB5C505C595B715C63
+5C667FBC5F2A5F295F2D82745F3C9B3B5C6E59815983598D59A959AA59A30000
+E6
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000599759CA59AB599E59A459D259B259AF59D759BE5A055A0659DD5A0859E3
+59D859F95A0C5A095A325A345A115A235A135A405A675A4A5A555A3C5A625A75
+80EC5AAA5A9B5A775A7A5ABE5AEB5AB25AD25AD45AB85AE05AE35AF15AD65AE6
+5AD85ADC5B095B175B165B325B375B405C155C1C5B5A5B655B735B515B535B62
+9A759A779A789A7A9A7F9A7D9A809A819A859A889A8A9A909A929A939A969A98
+9A9B9A9C9A9D9A9F9AA09AA29AA39AA59AA77E9F7EA17EA37EA57EA87EA90000
+E7
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00007EAD7EB07EBE7EC07EC17EC27EC97ECB7ECC7ED07ED47ED77EDB7EE07EE1
+7EE87EEB7EEE7EEF7EF17EF27F0D7EF67EFA7EFB7EFE7F017F027F037F077F08
+7F0B7F0C7F0F7F117F127F177F197F1C7F1B7F1F7F217F227F237F247F257F26
+7F277F2A7F2B7F2C7F2D7F2F7F307F317F327F337F355E7A757F5DDB753E9095
+738E739173AE73A2739F73CF73C273D173B773B373C073C973C873E573D9987C
+740A73E973E773DE73BA73F2740F742A745B7426742574287430742E742C0000
+E8
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000741B741A7441745C7457745574597477746D747E749C748E748074817487
+748B749E74A874A9749074A774D274BA97EA97EB97EC674C6753675E67486769
+67A56787676A6773679867A7677567A8679E67AD678B6777677C67F0680967D8
+680A67E967B0680C67D967B567DA67B367DD680067C367B867E2680E67C167FD
+6832683368606861684E6862684468646883681D68556866684168676840683E
+684A6849682968B5688F687468776893686B68C2696E68FC691F692068F90000
+E9
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000692468F0690B6901695768E369106971693969606942695D6984696B6980
+69986978693469CC6987698869CE6989696669636979699B69A769BB69AB69AD
+69D469B169C169CA69DF699569E0698D69FF6A2F69ED6A176A186A6569F26A44
+6A3E6AA06A506A5B6A356A8E6A796A3D6A286A586A7C6A916A906AA96A976AAB
+733773526B816B826B876B846B926B936B8D6B9A6B9B6BA16BAA8F6B8F6D8F71
+8F728F738F758F768F788F778F798F7A8F7C8F7E8F818F828F848F878F8B0000
+EA
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00008F8D8F8E8F8F8F988F9A8ECE620B6217621B621F6222622162256224622C
+81E774EF74F474FF750F75117513653465EE65EF65F0660A6619677266036615
+6600708566F7661D66346631663666358006665F66546641664F665666616657
+66776684668C66A7669D66BE66DB66DC66E666E98D328D338D368D3B8D3D8D40
+8D458D468D488D498D478D4D8D558D5989C789CA89CB89CC89CE89CF89D089D1
+726E729F725D7266726F727E727F7284728B728D728F72926308633263B00000
+EB
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000643F64D880046BEA6BF36BFD6BF56BF96C056C076C066C0D6C156C186C19
+6C1A6C216C296C246C2A6C3265356555656B724D72527256723086625216809F
+809C809380BC670A80BD80B180AB80AD80B480B780E780E880E980EA80DB80C2
+80C480D980CD80D7671080DD80EB80F180F480ED810D810E80F280FC67158112
+8C5A8136811E812C811881328148814C815381748159815A817181608169817C
+817D816D8167584D5AB58188818281916ED581A381AA81CC672681CA81BB0000
+EC
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000081C181A66B246B376B396B436B466B5998D198D298D398D598D998DA6BB3
+5F406BC289F365909F51659365BC65C665C465C365CC65CE65D265D67080709C
+7096709D70BB70C070B770AB70B170E870CA711071137116712F71317173715C
+716871457172714A7178717A719871B371B571A871A071E071D471E771F9721D
+7228706C7118716671B9623E623D624362486249793B794079467949795B795C
+7953795A796279577960796F7967797A7985798A799A79A779B35FD15FD00000
+ED
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000603C605D605A606760416059606360AB6106610D615D61A9619D61CB61D1
+62068080807F6C936CF66DFC77F677F87800780978177818781165AB782D781C
+781D7839783A783B781F783C7825782C78237829784E786D7856785778267850
+7847784C786A789B7893789A7887789C78A178A378B278B978A578D478D978C9
+78EC78F2790578F479137924791E79349F9B9EF99EFB9EFC76F17704770D76F9
+77077708771A77227719772D7726773577387750775177477743775A77680000
+EE
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000077627765777F778D777D7780778C7791779F77A077B077B577BD753A7540
+754E754B7548755B7572757975837F587F617F5F8A487F687F747F717F797F81
+7F7E76CD76E58832948594869487948B948A948C948D948F9490949494979495
+949A949B949C94A394A494AB94AA94AD94AC94AF94B094B294B494B694B794B8
+94B994BA94BC94BD94BF94C494C894C994CA94CB94CC94CD94CE94D094D194D2
+94D594D694D794D994D894DB94DE94DF94E094E294E494E594E794E894EA0000
+EF
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000094E994EB94EE94EF94F394F494F594F794F994FC94FD94FF950395029506
+95079509950A950D950E950F951295139514951595169518951B951D951E951F
+9522952A952B9529952C953195329534953695379538953C953E953F95429535
+9544954595469549954C954E954F9552955395549556955795589559955B955E
+955F955D95619562956495659566956795689569956A956B956C956F95719572
+9573953A77E777EC96C979D579ED79E379EB7A065D477A037A027A1E7A140000
+F0
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00007A397A377A519ECF99A57A707688768E7693769976A474DE74E0752C9E20
+9E229E289E299E2A9E2B9E2C9E329E319E369E389E379E399E3A9E3E9E419E42
+9E449E469E479E489E499E4B9E4C9E4E9E519E559E579E5A9E5B9E5C9E5E9E63
+9E669E679E689E699E6A9E6B9E6C9E719E6D9E7375927594759675A0759D75AC
+75A375B375B475B875C475B175B075C375C275D675CD75E375E875E675E475EB
+75E7760375F175FC75FF761076007605760C7617760A76257618761576190000
+F1
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000761B763C762276207640762D7630763F76357643763E7633764D765E7654
+765C7656766B766F7FCA7AE67A787A797A807A867A887A957AA67AA07AAC7AA8
+7AAD7AB3886488698872887D887F888288A288C688B788BC88C988E288CE88E3
+88E588F1891A88FC88E888FE88F0892189198913891B890A8934892B89368941
+8966897B758B80E576B276B477DC801280148016801C80208022802580268027
+802980288031800B803580438046804D80528069807189839878988098830000
+F2
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009889988C988D988F9894989A989B989E989F98A198A298A598A6864D8654
+866C866E867F867A867C867B86A8868D868B86AC869D86A786A386AA869386A9
+86B686C486B586CE86B086BA86B186AF86C986CF86B486E986F186F286ED86F3
+86D0871386DE86F486DF86D886D18703870786F88708870A870D87098723873B
+871E8725872E871A873E87488734873187298737873F87828722877D877E877B
+87608770874C876E878B87538763877C876487598765879387AF87A887D20000
+F3
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000087C68788878587AD8797878387AB87E587AC87B587B387CB87D387BD87D1
+87C087CA87DB87EA87E087EE8816881387FE880A881B88218839883C7F367F42
+7F447F4582107AFA7AFD7B087B037B047B157B0A7B2B7B0F7B477B387B2A7B19
+7B2E7B317B207B257B247B337B3E7B1E7B587B5A7B457B757B4C7B5D7B607B6E
+7B7B7B627B727B717B907BA67BA77BB87BAC7B9D7BA87B857BAA7B9C7BA27BAB
+7BB47BD17BC17BCC7BDD7BDA7BE57BE67BEA7C0C7BFE7BFC7C0F7C167C0B0000
+F4
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00007C1F7C2A7C267C387C417C4081FE82018202820481EC8844822182228223
+822D822F8228822B8238823B82338234823E82448249824B824F825A825F8268
+887E8885888888D888DF895E7F9D7F9F7FA77FAF7FB07FB27C7C65497C917C9D
+7C9C7C9E7CA27CB27CBC7CBD7CC17CC77CCC7CCD7CC87CC57CD77CE8826E66A8
+7FBF7FCE7FD57FE57FE17FE67FE97FEE7FF37CF87D777DA67DAE7E477E9B9EB8
+9EB48D738D848D948D918DB18D678D6D8C478C49914A9150914E914F91640000
+F5
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009162916191709169916F917D917E917291749179918C91859190918D9191
+91A291A391AA91AD91AE91AF91B591B491BA8C559E7E8DB88DEB8E058E598E69
+8DB58DBF8DBC8DBA8DC48DD68DD78DDA8DDE8DCE8DCF8DDB8DC68DEC8DF78DF8
+8DE38DF98DFB8DE48E098DFD8E148E1D8E1F8E2C8E2E8E238E2F8E3A8E408E39
+8E358E3D8E318E498E418E428E518E528E4A8E708E768E7C8E6F8E748E858E8F
+8E948E908E9C8E9E8C788C828C8A8C858C988C94659B89D689DE89DA89DC0000
+F6
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+000089E589EB89EF8A3E8B26975396E996F396EF970697019708970F970E972A
+972D9730973E9F809F839F859F869F879F889F899F8A9F8C9EFE9F0B9F0D96B9
+96BC96BD96CE96D277BF96E0928E92AE92C8933E936A93CA938F943E946B9C7F
+9C829C859C869C879C887A239C8B9C8E9C909C919C929C949C959C9A9C9B9C9E
+9C9F9CA09CA19CA29CA39CA59CA69CA79CA89CA99CAB9CAD9CAE9CB09CB19CB2
+9CB39CB49CB59CB69CB79CBA9CBB9CBC9CBD9CC49CC59CC69CC79CCA9CCB0000
+F7
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+00009CCC9CCD9CCE9CCF9CD09CD39CD49CD59CD79CD89CD99CDC9CDD9CDF9CE2
+977C978597919792979497AF97AB97A397B297B49AB19AB09AB79E589AB69ABA
+9ABC9AC19AC09AC59AC29ACB9ACC9AD19B459B439B479B499B489B4D9B5198E8
+990D992E995599549ADF9AE19AE69AEF9AEB9AFB9AED9AF99B089B0F9B139B1F
+9B239EBD9EBE7E3B9E829E879E889E8B9E9293D69E9D9E9F9EDB9EDC9EDD9EE0
+9EDF9EE29EE99EE79EE59EEA9EEF9F229F2C9F2F9F399F379F3D9F3E9F440000

janus/lib/tcl8.6/encoding/gb1988.enc

@@ -0,0 +1,20 @@
+# Encoding file: gb1988, single-byte
+S
+003F 0 1
+00
+0000000100020003000400050006000700080009000A000B000C000D000E000F
+0010001100120013001400150016001700180019001A001B001C001D001E001F
+002000210022002300A500250026002700280029002A002B002C002D002E002F
+0030003100320033003400350036003700380039003A003B003C003D003E003F
+0040004100420043004400450046004700480049004A004B004C004D004E004F
+0050005100520053005400550056005700580059005A005B005C005D005E005F
+0060006100620063006400650066006700680069006A006B006C006D006E006F
+0070007100720073007400750076007700780079007A007B007C007D203E007F
+0080008100820083008400850086008700880089008A008B008C008D008E008F
+0090009100920093009400950096009700980099009A009B009C009D009E009F
+0000FF61FF62FF63FF64FF65FF66FF67FF68FF69FF6AFF6BFF6CFF6DFF6EFF6F
+FF70FF71FF72FF73FF74FF75FF76FF77FF78FF79FF7AFF7BFF7CFF7DFF7EFF7F
+FF80FF81FF82FF83FF84FF85FF86FF87FF88FF89FF8AFF8BFF8CFF8DFF8EFF8F
+FF90FF91FF92FF93FF94FF95FF96FF97FF98FF99FF9AFF9BFF9CFF9DFF9EFF9F
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000

janus/lib/tcl8.6/encoding/iso2022-kr.enc

@@ -0,0 +1,7 @@
+# Encoding file: iso2022-kr, escape-driven
+E
+name		iso2022-kr
+init		\x1b$)C
+final		{}
+iso8859-1	\x0f
+ksc5601		\x0e